figpack 0.1.0__tar.gz → 0.1.1__tar.gz

{figpack-0.1.0 → figpack-0.1.1}/MANIFEST.in

@@ -1,8 +1,8 @@
 include README.md
 include LICENSE
 include pyproject.toml
-include build_gui.py
 recursive-include figpack *.py
 recursive-include figpack/figpack-gui-dist *
 global-exclude __pycache__
 global-exclude *.py[co]
+

{figpack-0.1.0/figpack.egg-info → figpack-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: figpack
-Version: 0.1.0
+Version: 0.1.1
 Summary: A Python package for creating shareable, interactive visualizations
 Author-email: Jeremy Magland <jmagland@flatironinstitute.org>
 License: Apache-2.0

figpack-0.1.1/figpack/core/_bundle_utils.py

@@ -0,0 +1,46 @@
+import os
+import pathlib
+import zarr
+from .figpack_view import FigpackView
+
+thisdir = pathlib.Path(__file__).parent.resolve()
+
+
+def prepare_figure_bundle(view: FigpackView, tmpdir: str) -> None:
+    """
+    Prepare a figure bundle in the specified temporary directory.
+
+    This function:
+    1. Copies all files from the figpack-gui-dist directory to tmpdir
+    2. Writes the view data to a zarr group
+    3. Consolidates zarr metadata
+
+    Args:
+        view: The figpack view to prepare
+        tmpdir: The temporary directory to prepare the bundle in
+    """
+    html_dir = thisdir / ".." / "figpack-gui-dist"
+    if not os.path.exists(html_dir):
+        raise SystemExit(f"Error: directory not found: {html_dir}")
+
+    # Copy all files in html_dir recursively to tmpdir
+    for item in html_dir.iterdir():
+        if item.is_file():
+            target = pathlib.Path(tmpdir) / item.name
+            target.write_bytes(item.read_bytes())
+        elif item.is_dir():
+            target = pathlib.Path(tmpdir) / item.name
+            target.mkdir(exist_ok=True)
+            for subitem in item.iterdir():
+                target_sub = target / subitem.name
+                target_sub.write_bytes(subitem.read_bytes())
+
+    # Write the graph data to the Zarr group
+    zarr_group = zarr.open_group(
+        pathlib.Path(tmpdir) / "data.zarr",
+        mode="w",
+        synchronizer=zarr.ThreadSynchronizer(),
+    )
+    view._write_to_zarr_group(zarr_group)
+
+    zarr.consolidate_metadata(zarr_group.store)

{figpack-0.1.0/figpack → figpack-0.1.1/figpack/core}/_show_view.py

@@ -1,7 +1,6 @@
 import os
 
 from typing import Union
-import zarr
 import tempfile
 
 import webbrowser
@@ -11,43 +10,21 @@ import pathlib
 import threading
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 
-from .views import TimeseriesGraph
+from .figpack_view import FigpackView
+from ._bundle_utils import prepare_figure_bundle
 
 thisdir = pathlib.Path(__file__).parent.resolve()
 
 
 def _show_view(
-    view: TimeseriesGraph,
+    view: FigpackView,
     *,
     open_in_browser: bool = False,
     port: Union[int, None] = None,
     allow_origin: Union[str, None] = None,
 ):
     with tempfile.TemporaryDirectory(prefix="figpack_") as tmpdir:
-        html_dir = thisdir / "figpack-gui-dist"
-        if not os.path.exists(html_dir):
-            raise SystemExit(f"Error: directory not found: {html_dir}")
-        # copy all files in html_dir recursively to tmpdir
-        for item in html_dir.iterdir():
-            if item.is_file():
-                target = pathlib.Path(tmpdir) / item.name
-                target.write_bytes(item.read_bytes())
-            elif item.is_dir():
-                target = pathlib.Path(tmpdir) / item.name
-                target.mkdir(exist_ok=True)
-                for subitem in item.iterdir():
-                    target_sub = target / subitem.name
-                    target_sub.write_bytes(subitem.read_bytes())
-
-        # Write the graph data to the Zarr group
-        zarr_group = zarr.open_group(
-            pathlib.Path(tmpdir) / "data.zarr",
-            mode="w",
-            synchronizer=zarr.ThreadSynchronizer(),
-        )
-        view._write_to_zarr_group(zarr_group)
-
-        zarr.consolidate_metadata(zarr_group.store)
+        prepare_figure_bundle(view, tmpdir)
 
         serve_files(
             tmpdir,

{figpack-0.1.0/figpack → figpack-0.1.1/figpack/core}/_upload_view.py

@@ -5,11 +5,12 @@ import uuid
 import tempfile
 import pathlib
 import requests
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timedelta, timezone
 
-import zarr
-
-from .views import TimeseriesGraph
+from .figpack_view import FigpackView
+from ._bundle_utils import prepare_figure_bundle
 
 thisdir = pathlib.Path(__file__).parent.resolve()
 
@@ -17,7 +18,7 @@ FIGPACK_API_BASE_URL = "https://figpack-api.vercel.app"
 TEMPORY_BASE_URL = "https://tempory.net/figpack/figures"
 
 
-def _upload_view(view: TimeseriesGraph) -> str:
+def _upload_view(view: FigpackView) -> str:
     """
     Upload a figpack view to the cloud
 
@@ -45,7 +46,7 @@ def _upload_view(view: TimeseriesGraph) -> str:
     with tempfile.TemporaryDirectory(prefix="figpack_upload_") as tmpdir:
         # Prepare the figure bundle (reuse logic from _show_view)
         print("Preparing figure bundle...")
-        _prepare_figure_bundle(view, tmpdir)
+        prepare_figure_bundle(view, tmpdir)
 
         # Upload the bundle
         print("Starting upload...")
@@ -58,40 +59,33 @@ def _upload_view(view: TimeseriesGraph) -> str:
         return figure_url
 
 
-def _prepare_figure_bundle(view: TimeseriesGraph, tmpdir: str) -> None:
+def _upload_single_file(
+    figure_id: str, relative_path: str, file_path: pathlib.Path, passcode: str
+) -> str:
     """
-    Prepare the figure bundle in the temporary directory
-    This reuses the same logic as _show_view
+    Worker function to upload a single file
+
+    Returns:
+        str: The relative path of the uploaded file
     """
-    html_dir = thisdir / "figpack-gui-dist"
-    if not os.path.exists(html_dir):
-        raise SystemExit(f"Error: directory not found: {html_dir}")
-
-    # Copy all files in html_dir recursively to tmpdir
-    for item in html_dir.iterdir():
-        if item.is_file():
-            target = pathlib.Path(tmpdir) / item.name
-            target.write_bytes(item.read_bytes())
-        elif item.is_dir():
-            target = pathlib.Path(tmpdir) / item.name
-            target.mkdir(exist_ok=True)
-            for subitem in item.iterdir():
-                target_sub = target / subitem.name
-                target_sub.write_bytes(subitem.read_bytes())
-
-    # Write the graph data to the Zarr group
-    zarr_group = zarr.open_group(
-        pathlib.Path(tmpdir) / "data.zarr",
-        mode="w",
-        synchronizer=zarr.ThreadSynchronizer(),
-    )
-    view._write_to_zarr_group(zarr_group)
-    zarr.consolidate_metadata(zarr_group.store)
+    file_type = _determine_file_type(relative_path)
+
+    if file_type == "small":
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        _upload_small_file(figure_id, relative_path, content, passcode)
+    else:  # large file
+        _upload_large_file(figure_id, relative_path, file_path, passcode)
+
+    return relative_path
+
+
+MAX_WORKERS_FOR_UPLOAD = 16
 
 
 def _upload_bundle(tmpdir: str, figure_id: str, passcode: str) -> None:
     """
-    Upload the prepared bundle to the cloud
+    Upload the prepared bundle to the cloud using parallel uploads
     """
     tmpdir_path = pathlib.Path(tmpdir)
 
@@ -116,42 +110,74 @@ def _upload_bundle(tmpdir: str, figure_id: str, passcode: str) -> None:
 
     print(f"Found {len(all_files)} files to upload")
 
-    # Upload files
-    uploaded_count = 0
-    timer = time.time()
-    for relative_path, file_path in all_files:
-        # Skip the figpack.json since we already uploaded the initial version
-        if relative_path == "figpack.json":
-            continue
-        file_type = _determine_file_type(relative_path)
-
-        if file_type == "small":
-            with open(file_path, "r", encoding="utf-8") as f:
-                content = f.read()
-            _upload_small_file(figure_id, relative_path, content, passcode)
-        else:  # large file
-            _upload_large_file(figure_id, relative_path, file_path, passcode)
-
-        uploaded_count += 1
-        print(f"Uploaded {uploaded_count}/{len(all_files)-1}: {relative_path}")
-        elapsed_time = time.time() - timer
-        if elapsed_time > 60:
-            figpack_json = {
-                **figpack_json,
-                "status": "uploading",
-                "upload_progress": f"{uploaded_count}/{len(all_files)-1}",
-                "upload_updated": datetime.now(timezone.utc).isoformat(),
+    # Filter out figpack.json since we already uploaded the initial version
+    files_to_upload = [
+        (rel_path, file_path)
+        for rel_path, file_path in all_files
+        if rel_path != "figpack.json"
+    ]
+    total_files_to_upload = len(files_to_upload)
+
+    if total_files_to_upload == 0:
+        print("No additional files to upload")
+    else:
+        print(
+            f"Uploading {total_files_to_upload} files with up to 8 concurrent uploads..."
+        )
+
+        # Thread-safe progress tracking
+        uploaded_count = 0
+        count_lock = threading.Lock()
+        timer = time.time()
+
+        # Upload files in parallel with concurrent uploads
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS_FOR_UPLOAD) as executor:
+            # Submit all upload tasks
+            future_to_file = {
+                executor.submit(
+                    _upload_single_file, figure_id, rel_path, file_path, passcode
+                ): rel_path
+                for rel_path, file_path in files_to_upload
             }
-            _upload_small_file(
-                figure_id,
-                "figpack.json",
-                json.dumps(figpack_json, indent=2),
-                passcode,
-            )
-            print(
-                f"Updated figpack.json with progress: {uploaded_count}/{len(all_files)-1}"
-            )
-            timer = time.time()
+
+            # Process completed uploads
+            for future in as_completed(future_to_file):
+                relative_path = future_to_file[future]
+                try:
+                    future.result()  # This will raise any exception that occurred during upload
+
+                    # Thread-safe progress update
+                    with count_lock:
+                        uploaded_count += 1
+                        print(
+                            f"Uploaded {uploaded_count}/{total_files_to_upload}: {relative_path}"
+                        )
+
+                        # Update progress every 60 seconds
+                        elapsed_time = time.time() - timer
+                        if elapsed_time > 60:
+                            figpack_json = {
+                                **figpack_json,
+                                "status": "uploading",
+                                "upload_progress": f"{uploaded_count}/{total_files_to_upload}",
+                                "upload_updated": datetime.now(
+                                    timezone.utc
+                                ).isoformat(),
+                            }
+                            _upload_small_file(
+                                figure_id,
+                                "figpack.json",
+                                json.dumps(figpack_json, indent=2),
+                                passcode,
+                            )
+                            print(
+                                f"Updated figpack.json with progress: {uploaded_count}/{total_files_to_upload}"
+                            )
+                            timer = time.time()
+
+                except Exception as e:
+                    print(f"Failed to upload {relative_path}: {e}")
+                    raise  # Re-raise the exception to stop the upload process
 
     # Finally, upload completion status
     print("Uploading completion status...")