pyview-web 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

pyview/assets/js/app.js

@@ -61,6 +61,7 @@ let csrfToken = document
 let liveSocket = new LiveSocket("/live", Socket, {
   hooks: Hooks,
   params: { _csrf_token: csrfToken },
+  uploaders: window.Uploaders || {},
 });
 
 // Show progress bar on live navigation and form submits

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();
+    });
+  };
+}

pyview/live_socket.py

@@ -47,9 +47,22 @@ class UnconnectedSocket(Generic[T]):
     connected: bool = False
 
     def allow_upload(
-        self, upload_name: str, constraints: UploadConstraints, auto_upload: bool = False, progress: Optional[Callable] = None
+        self,
+        upload_name: str,
+        constraints: UploadConstraints,
+        auto_upload: bool = False,
+        progress: Optional[Callable] = None,
+        external: Optional[Callable] = None,
+        entry_complete: Optional[Callable] = None,
     ) -> UploadConfig:
-        return UploadConfig(name=upload_name, constraints=constraints, autoUpload=auto_upload, progress_callback=progress)
+        return UploadConfig(
+            name=upload_name,
+            constraints=constraints,
+            autoUpload=auto_upload,
+            progress_callback=progress,
+            external_callback=external,
+            entry_complete_callback=entry_complete,
+        )
 
 
 class ConnectedLiveViewSocket(Generic[T]):
@@ -193,13 +206,40 @@ class ConnectedLiveViewSocket(Generic[T]):
         except Exception:
             logger.warning("Error sending navigation message", exc_info=True)
 
+    async def redirect(self, path: str, params: dict[str, Any] = {}):
+        """Redirect to a new location with full page reload"""
+        to = path
+        if params:
+            to = to + "?" + urlencode(params)
+
+        message = [
+            None,
+            None,
+            self.topic,
+            "redirect",
+            {"to": to},
+        ]
+
+        try:
+            await self.websocket.send_text(json.dumps(message))
+        except Exception:
+            logger.warning("Error sending redirect message", exc_info=True)
+
     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, auto_upload: bool = False, progress: Optional[Callable] = None
+        self,
+        upload_name: str,
+        constraints: UploadConstraints,
+        auto_upload: bool = False,
+        progress: Optional[Callable] = None,
+        external: Optional[Callable] = None,
+        entry_complete: Optional[Callable] = None,
     ) -> UploadConfig:
-        return self.upload_manager.allow_upload(upload_name, constraints, auto_upload, progress)
+        return self.upload_manager.allow_upload(
+            upload_name, constraints, auto_upload, progress, external, entry_complete
+        )
 
     async def close(self):
         self.connected = False

pyview/static/assets/app.js

@@ -39,9 +39,9 @@
     mod
   ));
 
-  // assets/node_modules/nprogress/nprogress.js
+  // node_modules/nprogress/nprogress.js
   var require_nprogress = __commonJS({
-    "assets/node_modules/nprogress/nprogress.js"(exports, module) {
+    "node_modules/nprogress/nprogress.js"(exports, module) {
       (function(root, factory) {
         if (typeof define === "function" && define.amd) {
           define(factory);
@@ -71,8 +71,7 @@
           var key, value;
           for (key in options) {
             value = options[key];
-            if (value !== void 0 && options.hasOwnProperty(key))
-              Settings[key] = value;
+            if (value !== void 0 && options.hasOwnProperty(key)) Settings[key] = value;
           }
           return this;
         };
@@ -84,8 +83,7 @@
           var progress = NProgress2.render(!started), bar = progress.querySelector(Settings.barSelector), speed = Settings.speed, ease = Settings.easing;
           progress.offsetWidth;
           queue(function(next) {
-            if (Settings.positionUsing === "")
-              Settings.positionUsing = NProgress2.getPositioningCSS();
+            if (Settings.positionUsing === "") Settings.positionUsing = NProgress2.getPositioningCSS();
             css(bar, barPositionCSS(n, speed, ease));
             if (n === 1) {
               css(progress, {
@@ -113,23 +111,19 @@
           return typeof NProgress2.status === "number";
         };
         NProgress2.start = function() {
-          if (!NProgress2.status)
-            NProgress2.set(0);
+          if (!NProgress2.status) NProgress2.set(0);
           var work = function() {
             setTimeout(function() {
-              if (!NProgress2.status)
-                return;
+              if (!NProgress2.status) return;
               NProgress2.trickle();
               work();
             }, Settings.trickleSpeed);
           };
-          if (Settings.trickle)
-            work();
+          if (Settings.trickle) work();
           return this;
         };
         NProgress2.done = function(force) {
-          if (!force && !NProgress2.status)
-            return this;
+          if (!force && !NProgress2.status) return this;
           return NProgress2.inc(0.3 + 0.5 * Math.random()).set(1);
         };
         NProgress2.inc = function(amount) {
@@ -171,8 +165,7 @@
           };
         })();
         NProgress2.render = function(fromStart) {
-          if (NProgress2.isRendered())
-            return document.getElementById("nprogress");
+          if (NProgress2.isRendered()) return document.getElementById("nprogress");
           addClass(document.documentElement, "nprogress-busy");
           var progress = document.createElement("div");
           progress.id = "nprogress";
@@ -213,10 +206,8 @@
           }
         };
         function clamp(n, min, max) {
-          if (n < min)
-            return min;
-          if (n > max)
-            return max;
+          if (n < min) return min;
+          if (n > max) return max;
           return n;
         }
         function toBarPerc(n) {
@@ -234,7 +225,7 @@
           barCSS.transition = "all " + speed + "ms " + ease;
           return barCSS;
         }
-        var queue = function() {
+        var queue = /* @__PURE__ */ (function() {
           var pending = [];
           function next() {
             var fn = pending.shift();
@@ -244,11 +235,10 @@
           }
           return function(fn) {
             pending.push(fn);
-            if (pending.length == 1)
-              next();
+            if (pending.length == 1) next();
           };
-        }();
-        var css = function() {
+        })();
+        var css = /* @__PURE__ */ (function() {
           var cssPrefixes = ["Webkit", "O", "Moz", "ms"], cssProps = {};
           function camelCase(string) {
             return string.replace(/^-ms-/, "ms-").replace(/-([\da-z])/gi, function(match, letter) {
@@ -257,13 +247,11 @@
           }
           function getVendorProp(name) {
             var style = document.body.style;
-            if (name in style)
-              return name;
+            if (name in style) return name;
             var i = cssPrefixes.length, capName = name.charAt(0).toUpperCase() + name.slice(1), vendorName;
             while (i--) {
               vendorName = cssPrefixes[i] + capName;
-              if (vendorName in style)
-                return vendorName;
+              if (vendorName in style) return vendorName;
             }
             return name;
           }
@@ -280,28 +268,25 @@
             if (args.length == 2) {
               for (prop in properties) {
                 value = properties[prop];
-                if (value !== void 0 && properties.hasOwnProperty(prop))
-                  applyCss(element, prop, value);
+                if (value !== void 0 && properties.hasOwnProperty(prop)) applyCss(element, prop, value);
               }
             } else {
               applyCss(element, args[1], args[2]);
             }
           };
-        }();
+        })();
         function hasClass(element, name) {
           var list = typeof element == "string" ? element : classList(element);
           return list.indexOf(" " + name + " ") >= 0;
         }
         function addClass(element, name) {
           var oldList = classList(element), newList = oldList + name;
-          if (hasClass(oldList, name))
-            return;
+          if (hasClass(oldList, name)) return;
           element.className = newList.substring(1);
         }
         function removeClass(element, name) {
           var oldList = classList(element), newList;
-          if (!hasClass(element, name))
-            return;
+          if (!hasClass(element, name)) return;
           newList = oldList.replace(" " + name + " ", " ");
           element.className = newList.substring(1, newList.length - 1);
         }
@@ -316,12 +301,11 @@
     }
   });
 
-  // assets/node_modules/phoenix_html/priv/static/phoenix_html.js
+  // node_modules/phoenix_html/priv/static/phoenix_html.js
   (function() {
     var PolyfillEvent = eventConstructor();
     function eventConstructor() {
-      if (typeof window.CustomEvent === "function")
-        return window.CustomEvent;
+      if (typeof window.CustomEvent === "function") return window.CustomEvent;
       function CustomEvent2(event, params) {
         params = params || { bubbles: false, cancelable: false, detail: void 0 };
         var evt = document.createEvent("CustomEvent");
@@ -343,10 +327,8 @@
       form.method = element.getAttribute("data-method") === "get" ? "get" : "post";
       form.action = to;
       form.style.display = "hidden";
-      if (target)
-        form.target = target;
-      else if (targetModifierKey)
-        form.target = "_blank";
+      if (target) form.target = target;
+      else if (targetModifierKey) form.target = "_blank";
       form.appendChild(csrf);
       form.appendChild(method);
       document.body.appendChild(form);
@@ -354,8 +336,7 @@
     }
     window.addEventListener("click", function(e) {
       var element = e.target;
-      if (e.defaultPrevented)
-        return;
+      if (e.defaultPrevented) return;
       while (element && element.getAttribute) {
         var phoenixLinkEvent = new PolyfillEvent("phoenix.link.click", {
           "bubbles": true,
@@ -383,7 +364,7 @@
     }, false);
   })();
 
-  // assets/node_modules/phoenix/priv/static/phoenix.mjs
+  // node_modules/phoenix/priv/static/phoenix.mjs
   var closure = (value) => {
     if (typeof value === "function") {
       return value;
@@ -1354,7 +1335,7 @@
     }
   };
 
-  // assets/node_modules/phoenix_live_view/priv/static/phoenix_live_view.esm.js
+  // node_modules/phoenix_live_view/priv/static/phoenix_live_view.esm.js
   var CONSECUTIVE_RELOADS = "consecutive-reloads";
   var MAX_RELOADS = 10;
   var RELOAD_JITTER_MIN = 5e3;
@@ -5457,7 +5438,7 @@ within:
     }
   };
 
-  // assets/js/app.js
+  // js/app.js
   var import_nprogress = __toESM(require_nprogress());
   var _a;
   var Hooks2 = (_a = window.Hooks) != null ? _a : {};
@@ -5487,7 +5468,8 @@ within:
   var csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content");
   var liveSocket = new LiveSocket("/live", Socket, {
     hooks: Hooks2,
-    params: { _csrf_token: csrfToken }
+    params: { _csrf_token: csrfToken },
+    uploaders: window.Uploaders || {}
   });
   window.addEventListener("phx:page-loading-start", (info) => import_nprogress.default.start());
   window.addEventListener("phx:page-loading-stop", (info) => import_nprogress.default.done());

pyview/static/assets/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();
+    });
+  };
+}

pyview/uploads.py

@@ -2,7 +2,7 @@ import datetime
 import uuid
 import logging
 from pydantic import BaseModel, Field
-from typing import Optional, Any, Literal, Generator, Callable
+from typing import Optional, Any, Literal, Generator, Callable, Awaitable
 from dataclasses import dataclass, field
 from contextlib import contextmanager
 import os
@@ -11,24 +11,60 @@ import tempfile
 logger = logging.getLogger(__name__)
 
 
+@dataclass
+class UploadSuccess:
+    """Upload completed successfully (no additional data needed). """
+    pass
+
+
+@dataclass
+class UploadSuccessWithData:
+    """Upload completed successfully with completion data.
+
+    Used for multipart uploads where the client sends additional data like:
+    - upload_id: S3 multipart upload ID
+    - parts: List of {PartNumber, ETag} dicts
+    - key: S3 object key
+    - Any other provider-specific fields
+    """
+    data: dict
+
+
+@dataclass
+class UploadFailure:
+    """Upload failed with an error.
+
+    Used when the client reports an upload error.
+    """
+    error: str
+
+
+# Type alias for upload completion results
+UploadResult = UploadSuccess | UploadSuccessWithData | UploadFailure
+
+
 @dataclass
 class ConstraintViolation:
     ref: str
-    code: Literal["too_large", "too_many_files"]
+    code: Literal["too_large", "too_many_files", "upload_failed"]
 
     @property
     def message(self) -> str:
         if self.code == "too_large":
             return "File too large"
-        return "Too many files"
+        if self.code == "too_many_files":
+            return "Too many files"
+        if self.code == "upload_failed":
+            return "Upload failed"
+        return self.code
 
 
 class UploadEntry(BaseModel):
-    path: str
     ref: str
     name: str
     size: int
     type: str
+    path: Optional[str] = None  # None for external uploads, set for internal uploads
     upload_config: Optional["UploadConfig"] = None
     uuid: str = Field(default_factory=lambda: str(uuid.uuid4()))
     valid: bool = True
@@ -40,6 +76,7 @@ class UploadEntry(BaseModel):
     last_modified: int = Field(
         default_factory=lambda: int(datetime.datetime.now().timestamp())
     )
+    meta: Optional["ExternalUploadMeta"] = None  # Metadata from external uploads
 
 
 def parse_entries(entries: list[dict]) -> list[UploadEntry]:
@@ -90,6 +127,20 @@ class ActiveUploads:
             upload.close()
 
 
+class ExternalUploadMeta(BaseModel):
+    """Metadata returned by external upload presign functions.
+
+    The 'uploader' field is required and specifies the name of the client-side
+    JavaScript uploader (e.g., "S3", "GCS", "Azure").
+
+    Additional provider-specific fields (url, fields, etc.) can be added as needed.
+    """
+    uploader: str  # Required - name of client-side JS uploader
+
+    # Allow extra fields for provider-specific data (url, fields, etc.)
+    model_config = {"extra": "allow"}
+
+
 class UploadConstraints(BaseModel):
     max_file_size: int = 10 * 1024 * 1024  # 10MB
     max_files: int = 10
@@ -105,7 +156,15 @@ class UploadConfig(BaseModel):
     errors: list[ConstraintViolation] = Field(default_factory=list)
     autoUpload: bool = False
     constraints: UploadConstraints = Field(default_factory=UploadConstraints)
-    progress_callback: Optional[Callable] = None
+    progress_callback: Optional[
+        Callable[[UploadEntry, Any], Awaitable[None]]
+    ] = None
+    external_callback: Optional[
+        Callable[[UploadEntry, Any], Awaitable[ExternalUploadMeta]]
+    ] = None
+    entry_complete_callback: Optional[
+        Callable[[UploadEntry, UploadResult, Any], Awaitable[None]]
+    ] = None
 
     uploads: ActiveUploads = Field(default_factory=ActiveUploads)
 
@@ -113,6 +172,11 @@ class UploadConfig(BaseModel):
     def entries(self) -> list[UploadEntry]:
         return list(self.entries_by_ref.values())
 
+    @property
+    def is_external(self) -> bool:
+        """Returns True if this upload config uses external (direct-to-cloud) uploads"""
+        return self.external_callback is not None
+
     def cancel_entry(self, ref: str):
         del self.entries_by_ref[ref]
 
@@ -154,19 +218,19 @@ class UploadConfig(BaseModel):
             self.uploads = ActiveUploads()
             self.entries_by_ref = {}
 
-    @contextmanager  
+    @contextmanager
     def consume_upload_entry(self, entry_ref: str) -> Generator[Optional["ActiveUpload"], None, None]:
         """Consume a single upload entry by its ref"""
         upload = None
         join_ref = None
-        
+
         # Find the join_ref for this entry
         for jr, active_upload in self.uploads.uploads.items():
             if active_upload.entry.ref == entry_ref:
                 upload = active_upload
                 join_ref = jr
                 break
-        
+
         try:
             yield upload
         finally:
@@ -175,13 +239,64 @@ class UploadConfig(BaseModel):
                     upload.close()
                 except Exception:
                     logger.warning("Error closing upload entry", exc_info=True)
-                
+
                 # Remove only this specific upload
                 if join_ref in self.uploads.uploads:
                     del self.uploads.uploads[join_ref]
                 if entry_ref in self.entries_by_ref:
                     del self.entries_by_ref[entry_ref]
 
+    @contextmanager
+    def consume_external_upload(self, entry_ref: str) -> Generator[Optional["UploadEntry"], None, None]:
+        """Consume a single external upload entry by its ref.
+
+        For external uploads (direct-to-cloud), this returns the UploadEntry containing
+        metadata about the uploaded file. The entry is automatically removed after the
+        context manager exits.
+
+        Args:
+            entry_ref: The ref of the entry to consume
+
+        Yields:
+            UploadEntry if found, None otherwise
+
+        Raises:
+            ValueError: If called on a non-external upload config
+        """
+        if not self.is_external:
+            raise ValueError("consume_external_upload() can only be called on external upload configs")
+
+        entry = self.entries_by_ref.get(entry_ref)
+
+        try:
+            yield entry
+        finally:
+            if entry_ref in self.entries_by_ref:
+                del self.entries_by_ref[entry_ref]
+
+    @contextmanager
+    def consume_external_uploads(self) -> Generator[list["UploadEntry"], None, None]:
+        """Consume all external upload entries and clean up.
+
+        For external uploads (direct-to-cloud), this returns the UploadEntry objects
+        containing metadata about the uploaded files. The entries are automatically
+        cleared after the context manager exits.
+
+        Yields:
+            List of UploadEntry objects
+
+        Raises:
+            ValueError: If called on a non-external upload config
+        """
+        if not self.is_external:
+            raise ValueError("consume_external_uploads() can only be called on external upload configs")
+
+        try:
+            upload_list = list(self.entries_by_ref.values())
+            yield upload_list
+        finally:
+            self.entries_by_ref = {}
+
     def close(self):
         self.uploads.close()
 
@@ -195,9 +310,22 @@ class UploadManager:
         self.upload_config_join_refs = {}
 
     def allow_upload(
-        self, upload_name: str, constraints: UploadConstraints, auto_upload: bool = False, progress: Optional[Callable] = None
+        self,
+        upload_name: str,
+        constraints: UploadConstraints,
+        auto_upload: bool = False,
+        progress: Optional[Callable] = None,
+        external: Optional[Callable] = None,
+        entry_complete: Optional[Callable] = None,
     ) -> UploadConfig:
-        config = UploadConfig(name=upload_name, constraints=constraints, autoUpload=auto_upload, progress_callback=progress)
+        config = UploadConfig(
+            name=upload_name,
+            constraints=constraints,
+            autoUpload=auto_upload,
+            progress_callback=progress,
+            external_callback=external,
+            entry_complete_callback=entry_complete,
+        )
         self.upload_configs[upload_name] = config
         return config
 
@@ -220,34 +348,98 @@ class UploadManager:
                 else:
                     logger.warning("Upload config not found for ref: %s", 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:
-            logger.warning("Can't find upload config for ref: %s", ref)
-            return {"error": [(ref, "not_found")]}
-
-        proposed_entries = payload["entries"]
-
+    def _validate_constraints(
+        self, config: UploadConfig, proposed_entries: list[dict[str, Any]]
+    ) -> list[ConstraintViolation]:
+        """Validate proposed entries against upload constraints."""
         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"))
+            errors.append(ConstraintViolation(ref=config.ref, code="too_many_files"))
 
-        if errors:
-            return {"error": [(e.ref, e.code) for e in errors]}
+        return errors
+
+    async def _process_external_upload(
+        self, config: UploadConfig, proposed_entries: list[dict[str, Any]], context: Any
+    ) -> dict[str, Any]:
+        """Process external (direct-to-cloud) upload by calling presign function for each entry."""
+        entries_with_meta = {}
+        successfully_preflighted = []  # Track entries added to config for atomic cleanup
+
+        if not config.external_callback:
+            logger.error("external_callback is required for external uploads")
+            return {"error": [("config", "external_callback_missing")]}
+
+        for entry_data in proposed_entries:
+            # Create UploadEntry to pass to presign function
+            entry = UploadEntry(**entry_data)
+            entry.upload_config = config
+
+            try:
+                # Call user's presign function
+                meta: ExternalUploadMeta = await config.external_callback(entry, context)
+
+                # Store metadata and mark entry as preflighted
+                entry.meta = meta
+                entry.preflighted = True
+                config.entries_by_ref[entry.ref] = entry
+                successfully_preflighted.append(entry.ref)  # Track for cleanup
+
+                # Build entry JSON with metadata merged at top level
+                entry_dict = entry.model_dump(exclude={"upload_config", "meta"})
+                entry_dict.update(meta.model_dump())  # Merge meta fields into entry
+                entries_with_meta[entry.ref] = entry_dict
+
+            except Exception as e:
+                logger.error(f"Error calling presign function for entry {entry.ref}: {e}", exc_info=True)
+
+                # Atomic cleanup: remove all entries added before this failure
+                for ref in successfully_preflighted:
+                    config.entries_by_ref.pop(ref, None)
+
+                return {"error": [(entry.ref, "presign_error")]}
 
+        configJson = config.constraints.model_dump()
+        return {"config": configJson, "entries": entries_with_meta}
+
+    def _process_internal_upload(self, config: UploadConfig) -> dict[str, Any]:
+        """Process internal (direct-to-server) upload."""
         configJson = config.constraints.model_dump()
         entryJson = {
             e.ref: e.model_dump(exclude={"upload_config"}) for e in config.entries
         }
-
         return {"config": configJson, "entries": entryJson}
 
+    async def process_allow_upload(self, payload: dict[str, Any], context: Any) -> dict[str, Any]:
+        """Process allow_upload request from client.
+
+        Validates constraints and either:
+        - For external uploads: calls presign function to generate upload metadata
+        - For internal uploads: returns standard config/entries response
+        """
+        ref = payload["ref"]
+        config = self.config_for_ref(ref)
+
+        if not config:
+            logger.warning("Can't find upload config for ref: %s", ref)
+            return {"error": [(ref, "not_found")]}
+
+        proposed_entries = payload["entries"]
+
+        # Validate constraints
+        errors = self._validate_constraints(config, proposed_entries)
+        if errors:
+            return {"error": [(e.ref, e.code) for e in errors]}
+
+        # Handle external vs internal uploads
+        if config.is_external:
+            return await self._process_external_upload(config, proposed_entries, context)
+        else:
+            return self._process_internal_upload(config)
+
     def add_upload(self, joinRef: str, payload: dict[str, Any]):
         token = payload["token"]
 
@@ -262,16 +454,59 @@ class UploadManager:
         config.uploads.add_chunk(joinRef, chunk)
         pass
 
-    def update_progress(self, joinRef: str, payload: dict[str, Any]):
+    async def update_progress(self, joinRef: str, payload: dict[str, Any], socket):
         upload_config_ref = payload["ref"]
         entry_ref = payload["entry_ref"]
-        progress = int(payload["progress"])
+        progress_data = payload["progress"]
 
         config = self.config_for_ref(upload_config_ref)
-        if config:
-            config.update_progress(entry_ref, progress)
+        if not config:
+            logger.warning(f"[update_progress] No config found for ref: {upload_config_ref}")
+            return
+
+        # Handle dict (error or completion)
+        if isinstance(progress_data, dict):
+            if progress_data.get('complete'):
+                entry = config.entries_by_ref.get(entry_ref)
+                if entry:
+                    entry.progress = 100
+                    entry.done = True
+
+                    # Call entry_complete callback with success result
+                    if config.entry_complete_callback:
+                        result = UploadSuccessWithData(data=progress_data)
+                        await config.entry_complete_callback(entry, result, socket)
+                return
+
+            # Handle error case: {error: "reason"}
+            error_msg = progress_data.get('error', 'Upload failed')
+            logger.warning(f"Upload error for entry {entry_ref}: {error_msg}")
 
-            if progress == 100:
+            if entry_ref in config.entries_by_ref:
+                entry = config.entries_by_ref[entry_ref]
+                entry.valid = False
+                entry.done = True
+                entry.errors.append(ConstraintViolation(ref=entry_ref, code="upload_failed"))
+
+                # Call entry_complete callback with failure result
+                if config.entry_complete_callback:
+                    result = UploadFailure(error=error_msg)
+                    await config.entry_complete_callback(entry, result, socket)
+            return
+
+        # Handle progress number
+        progress = int(progress_data)
+        config.update_progress(entry_ref, progress)
+
+        # Fire entry_complete callback on 100
+        if progress == 100:
+            entry = config.entries_by_ref.get(entry_ref)
+            if entry and config.entry_complete_callback:
+                result = UploadSuccess()
+                await config.entry_complete_callback(entry, result, socket)
+
+            # Cleanup for internal uploads only (external uploads never populate upload_config_join_refs)
+            if not config.is_external:
                 try:
                     joinRef_to_remove = config.uploads.join_ref_for_entry(entry_ref)
                     if joinRef_to_remove in self.upload_config_join_refs:
@@ -288,15 +523,20 @@ class UploadManager:
         """Trigger progress callback if one exists for this upload config"""
         upload_config_ref = payload["ref"]
         config = self.config_for_ref(upload_config_ref)
-        
+
         if config and config.progress_callback:
             entry_ref = payload["entry_ref"]
             if entry_ref in config.entries_by_ref:
                 entry = config.entries_by_ref[entry_ref]
+                progress_data = payload["progress"]
+
                 # Update entry progress before calling callback
-                progress = int(payload["progress"])
-                entry.progress = progress
-                entry.done = progress == 100
+                if isinstance(progress_data, int):
+                    entry.progress = progress_data
+                    entry.done = progress_data == 100
+                # For dict (error or completion), don't update entry.progress here
+                # (will be handled in update_progress or completion handler)
+
                 await config.progress_callback(entry, socket)
 
     def close(self):

pyview/ws_handler.py

@@ -228,8 +228,8 @@ class LiveSocketHandler:
                 continue
 
             if event == "allow_upload":
-                allow_upload_response = socket.upload_manager.process_allow_upload(
-                    payload
+                allow_upload_response = await socket.upload_manager.process_allow_upload(
+                    payload, socket.context
                 )
 
                 rendered = await _render(socket)
@@ -342,9 +342,9 @@ class LiveSocketHandler:
             if event == "progress":
                 # Trigger progress callback BEFORE updating progress (which may consume the entry)
                 await socket.upload_manager.trigger_progress_callback_if_exists(payload, socket)
-                
-                socket.upload_manager.update_progress(joinRef, payload)
-                
+
+                await socket.upload_manager.update_progress(joinRef, payload, socket)
+
                 rendered = await _render(socket)
                 diff = socket.diff(rendered)
 

{pyview_web-0.4.2.dist-info → pyview_web-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyview-web
-Version: 0.4.2
+Version: 0.5.1
 Summary: LiveView in Python
 License: MIT
 License-File: LICENSE

{pyview_web-0.4.2.dist-info → pyview_web-0.5.1.dist-info}/RECORD

@@ -1,5 +1,6 @@
 pyview/__init__.py,sha256=5RJ_KtwJvI_-_Vhb3-py5Qf78YdH1HHvAzZO1ddzzrU,518
-pyview/assets/js/app.js,sha256=XuuSgEMY4hx8v0OuEPwaa7trktu_vppL0tc3Bs9Fw7s,2524
+pyview/assets/js/app.js,sha256=8Y3mGEf6KeqBUSzyYFalnzD6U_r5hhU332RyQSXwW0w,2561
+pyview/assets/js/uploaders.js,sha256=fKqvmGSfM_dIalcldqy_Zd-4Jv_7ruucfC6hdoPW2QQ,8249
 pyview/assets/package-lock.json,sha256=kFCrEUJc3G7VD7EsBQf6__EKQhaKAok-I5rrwiAoX0w,2425
 pyview/assets/package.json,sha256=E6xaX8KMUAektIIedLmI55jGnmlNMSeD2tgKYXWk1vg,151
 pyview/async_stream_runner.py,sha256=_vXeU1LyuQkJrK5AlaaF1gyhRFWXhzn3Y73BFhSsWVc,2289
@@ -21,14 +22,15 @@ pyview/instrumentation/interfaces.py,sha256=AhVDM_vzETWtM-wfOXaM13K2OgdL0H8lu5wh
 pyview/instrumentation/noop.py,sha256=VP8UjiI--A7KWqnSFh7PMG7MqY0Z9ddQjBYVW7iHZa0,2941
 pyview/js.py,sha256=E6HMsUfXQjrcLqYq26ieeYuzTjBeZqfJwwOm3uSR4ME,3498
 pyview/live_routes.py,sha256=IN2Jmy8b1umcfx1R7ZgFXHZNbYDJp_kLIbADtDJknPM,1749
-pyview/live_socket.py,sha256=s41hancNG_hJOl17SSSc2Bg2UzxbBF8mihk4AedFy3k,6972
+pyview/live_socket.py,sha256=OqdoN6SiWSYbzjsY_nNbhm9_swAC5VQhjS--HmxzMxA,7965
 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=2rj7NMuc6-tml2Wg4PBV7tydFJVa6XUw0pM0voWYg5g,2972
 pyview/secret.py,sha256=HbaNpGAkFs4uxMVAmk9HwE3FIehg7dmwEOlED7C9moM,363
 pyview/session.py,sha256=nC8ExyVwfCgQfx9T-aJGyFhr2C7jsrEY_QFkaXtP28U,432
-pyview/static/assets/app.js,sha256=QoXfdcOCYwVYJftvjsIIVwFye7onaOJMxRpalyYqoMU,200029
+pyview/static/assets/app.js,sha256=pr_xqmsWzA63ebjdkogJLpTUPFI8xZFvcOn1fv1IVxI,199828
+pyview/static/assets/uploaders.js,sha256=fKqvmGSfM_dIalcldqy_Zd-4Jv_7ruucfC6hdoPW2QQ,8249
 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
@@ -36,7 +38,7 @@ pyview/template/render_diff.py,sha256=1P-OgtcGb0Y-zJ9uUH3bKWX-qQTHBa4jgg73qJD7eg
 pyview/template/root_template.py,sha256=zCUs1bt8R7qynhBE0tTSEYfdkGtbeKNmPhwzRiFNdsI,2031
 pyview/template/serializer.py,sha256=WDZfqJr2LMlf36fUW2CmWc2aREc63553_y_GRP2-qYc,826
 pyview/template/utils.py,sha256=S8593UjUJztUrtC3h1EL9MxQp5uH7rFDTNkv9C6A_xU,642
-pyview/uploads.py,sha256=G8zcVoTfWUjFs4nW3XZj60PqWujWTw2Rs3WOyyo52nY,12077
+pyview/uploads.py,sha256=eQGfvYTUuhdEfcTBBPlWPlhpWaN7b70m1Ph0HXaTPP0,21369
 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
@@ -50,9 +52,9 @@ pyview/vendor/ibis/nodes.py,sha256=TgFt4q5MrVW3gC3PVitrs2LyXKllRveooM7XKydNATk,2
 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=f6iI4vvLesepI9tCTHLyRBbdKCGPS6Gzj_UUjfIrPT8,14722
-pyview_web-0.4.2.dist-info/METADATA,sha256=-tCEwOMH_NssPzXFOfuhSwVQ75TpDGiV6ltYZ3HXsSE,5280
-pyview_web-0.4.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-pyview_web-0.4.2.dist-info/entry_points.txt,sha256=GAT-ic-VYmmSMUSUVKdV1bp4w-vgEeVP-XzElvarQ9U,42
-pyview_web-0.4.2.dist-info/licenses/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
-pyview_web-0.4.2.dist-info/RECORD,,
+pyview/ws_handler.py,sha256=vBsYxr7C7qs8sKcHQuxMnuuBv7_B-DPc1oq_YSrI1ms,14726
+pyview_web-0.5.1.dist-info/METADATA,sha256=uDi_cHRZuItEHHRu9q4GEDeyOkmvY3HZO6SqngtA6VI,5280
+pyview_web-0.5.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+pyview_web-0.5.1.dist-info/entry_points.txt,sha256=GAT-ic-VYmmSMUSUVKdV1bp4w-vgEeVP-XzElvarQ9U,42
+pyview_web-0.5.1.dist-info/licenses/LICENSE,sha256=M_bADaBm9_MV9llX3lCicksLhwk3eZUjA2srE0uUWr0,1071
+pyview_web-0.5.1.dist-info/RECORD,,