figpack 0.2.17__py3-none-any.whl → 0.2.40__py3-none-any.whl

figpack/core/_server_manager.py

@@ -28,13 +28,120 @@ class CORSRequestHandler(SimpleHTTPRequestHandler):
                 "Access-Control-Expose-Headers",
                 "Accept-Ranges, Content-Encoding, Content-Length, Content-Range",
             )
+
+        # Always send Accept-Ranges header to indicate byte-range support
+        self.send_header("Accept-Ranges", "bytes")
+
+        # Prevent browser caching - important for when we are editing figures in place
+        # This ensures the browser always fetches the latest version of files
+        self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
+        self.send_header("Pragma", "no-cache")
+        self.send_header("Expires", "0")
+
         super().end_headers()
 
     def do_OPTIONS(self):
         self.send_response(204, "No Content")
         self.end_headers()
 
-    def log_message(self, fmt, *args):
+    def do_PUT(self):
+        """Reject PUT requests when file upload is not enabled."""
+        self.send_error(405, "Method Not Allowed")
+
+    def do_GET(self):
+        """Handle GET requests with support for Range requests."""
+        # Translate path and check if file exists
+        path = self.translate_path(self.path)
+
+        # Check if path is a file
+        if not os.path.isfile(path):
+            # Let parent class handle directories and 404s
+            return super().do_GET()
+
+        # Check for Range header
+        range_header = self.headers.get("Range")
+
+        if range_header is None:
+            # No range request, use parent's implementation
+            return super().do_GET()
+
+        # Parse range header
+        try:
+            # Range header format: "bytes=start-end"
+            if not range_header.startswith("bytes="):
+                # Invalid range format, ignore and serve full file
+                return super().do_GET()
+
+            range_spec = range_header[6:]  # Remove "bytes=" prefix
+
+            # Get file size
+            file_size = os.path.getsize(path)
+
+            # Parse range specification
+            if "-" not in range_spec:
+                # Invalid format
+                self.send_error(400, "Invalid Range header")
+                return
+
+            range_parts = range_spec.split("-", 1)
+
+            # Determine start and end positions
+            if range_parts[0]:  # Start position specified
+                start = int(range_parts[0])
+                if range_parts[1]:  # End position also specified
+                    end = int(range_parts[1])
+                else:  # Open-ended range (e.g., "1024-")
+                    end = file_size - 1
+            else:  # Suffix range (e.g., "-500" means last 500 bytes)
+                if not range_parts[1]:
+                    self.send_error(400, "Invalid Range header")
+                    return
+                suffix_length = int(range_parts[1])
+                start = max(0, file_size - suffix_length)
+                end = file_size - 1
+
+            # Validate range
+            if start < 0 or end >= file_size or start > end:
+                self.send_response(416, "Range Not Satisfiable")
+                self.send_header("Content-Range", f"bytes */{file_size}")
+                self.end_headers()
+                return
+
+            # Calculate content length
+            content_length = end - start + 1
+
+            # Guess content type
+            import mimetypes
+
+            content_type = mimetypes.guess_type(path)[0] or "application/octet-stream"
+
+            # Send 206 Partial Content response
+            self.send_response(206, "Partial Content")
+            self.send_header("Content-Type", content_type)
+            self.send_header("Content-Length", str(content_length))
+            self.send_header("Content-Range", f"bytes {start}-{end}/{file_size}")
+            self.end_headers()
+
+            # Send the requested byte range
+            with open(path, "rb") as f:
+                f.seek(start)
+                remaining = content_length
+                while remaining > 0:
+                    chunk_size = min(8192, remaining)
+                    chunk = f.read(chunk_size)
+                    if not chunk:
+                        break
+                    self.wfile.write(chunk)
+                    remaining -= len(chunk)
+
+        except ValueError:
+            # Invalid range values
+            self.send_error(400, "Invalid Range header")
+        except Exception as e:
+            # Log error and return 500
+            self.send_error(500, f"Internal Server Error: {str(e)}")
+
+    def log_message(self, format, *args):
         pass
 
 
@@ -153,11 +260,21 @@ class ProcessServerManager:
         return figure_dir
 
     def start_server(
-        self, port: Optional[int] = None, allow_origin: Optional[str] = None
+        self,
+        port: Optional[int] = None,
+        allow_origin: Optional[str] = None,
+        enable_file_upload: bool = False,
+        max_file_size: int = 10 * 1024 * 1024,
     ) -> tuple[str, int]:
         """
         Start the server if not already running, or return existing server info.
 
+        Args:
+            port: Port to bind to (auto-selected if None)
+            allow_origin: CORS origin to allow (None for no CORS)
+            enable_file_upload: Whether to enable PUT requests for file uploads
+            max_file_size: Maximum file size in bytes for uploads (default 10MB)
+
         Returns:
             tuple: (base_url, port)
         """
@@ -168,6 +285,7 @@ class ProcessServerManager:
             and self._server_thread.is_alive()
             and (allow_origin is None or self._allow_origin == allow_origin)
         ):
+            assert self._port is not None
             return f"http://localhost:{self._port}", self._port
 
         # Stop existing server if settings are incompatible
@@ -184,13 +302,34 @@ class ProcessServerManager:
 
         temp_dir = self.get_temp_dir()
 
-        # Configure handler with directory and allow_origin
-        def handler_factory(*args, **kwargs):
-            return CORSRequestHandler(
-                *args, directory=str(temp_dir), allow_origin=allow_origin, **kwargs
+        # Choose handler based on file upload requirement
+        if enable_file_upload:
+            from ._file_handler import FileUploadCORSRequestHandler
+
+            def handler_factory_enable_upload(*args, **kwargs):
+                return FileUploadCORSRequestHandler(
+                    *args,
+                    directory=str(temp_dir),
+                    allow_origin=allow_origin,
+                    enable_file_upload=True,
+                    max_file_size=max_file_size,
+                    **kwargs,
+                )
+
+            assert port is not None
+            self._server = ThreadingHTTPServer(
+                ("0.0.0.0", port), handler_factory_enable_upload
             )
 
-        self._server = ThreadingHTTPServer(("0.0.0.0", port), handler_factory)
+        else:
+
+            def handler_factory(*args, **kwargs):
+                return CORSRequestHandler(
+                    *args, directory=str(temp_dir), allow_origin=allow_origin, **kwargs
+                )
+
+            assert port is not None
+            self._server = ThreadingHTTPServer(("0.0.0.0", port), handler_factory)
         self._port = port
         self._allow_origin = allow_origin
 

figpack/core/_show_view.py

@@ -19,7 +19,7 @@ def _is_in_notebook() -> bool:
     """
     try:
         # Check if IPython is available and we're in a notebook
-        from IPython import get_ipython
+        from IPython import get_ipython  # type: ignore
 
         ipython = get_ipython()
         if ipython is None:
@@ -148,7 +148,7 @@ def _show_view(
 
         # Start or get existing server
         base_url, server_port = server_manager.start_server(
-            port=port, allow_origin=allow_origin
+            port=port, allow_origin=allow_origin, enable_file_upload=True
         )
 
         # Construct URL to the specific figure subdirectory

figpack/core/_upload_bundle.py

@@ -1,11 +1,10 @@
+from typing import Optional, Union
 import hashlib
 import json
 import pathlib
 import threading
 import time
-import uuid
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime, timedelta, timezone
 
 import requests
 
@@ -116,62 +115,31 @@ def _upload_single_file_with_signed_url(
         else:
             break
 
+    assert last_exception is not None
     raise last_exception
 
 
 MAX_WORKERS_FOR_UPLOAD = 16
 
 
-def _compute_deterministic_figure_hash(tmpdir_path: pathlib.Path) -> str:
-    """
-    Compute a deterministic figure ID based on SHA1 hashes of all files
-
-    Returns:
-        str: 40-character SHA1 hash representing the content of all files
-    """
-    file_hashes = []
-
-    # Collect all files and their hashes
-    for file_path in sorted(tmpdir_path.rglob("*")):
-        if file_path.is_file():
-            relative_path = file_path.relative_to(tmpdir_path)
-
-            # Compute SHA1 hash of file content
-            sha1_hash = hashlib.sha1()
-            with open(file_path, "rb") as f:
-                for chunk in iter(lambda: f.read(4096), b""):
-                    sha1_hash.update(chunk)
-
-            # Include both the relative path and content hash to ensure uniqueness
-            file_info = f"{relative_path}:{sha1_hash.hexdigest()}"
-            file_hashes.append(file_info)
-
-    # Create final hash from all file hashes
-    combined_hash = hashlib.sha1()
-    for file_hash in file_hashes:
-        combined_hash.update(file_hash.encode("utf-8"))
-
-    return combined_hash.hexdigest()
-
-
 def _create_or_get_figure(
-    figure_hash: str,
-    api_key: str,
-    total_files: int = None,
-    total_size: int = None,
-    title: str = None,
+    api_key: Optional[str],
+    total_files: Optional[int] = None,
+    total_size: Optional[int] = None,
+    title: Optional[str] = None,
     ephemeral: bool = False,
+    source_url: Optional[str] = None,
 ) -> dict:
     """
     Create a new figure or get existing figure information
 
     Args:
-        figure_hash: The hash of the figure
         api_key: The API key for authentication (required for non-ephemeral)
         total_files: Optional total number of files
         total_size: Optional total size of files
         title: Optional title for the figure
         ephemeral: Whether to create an ephemeral figure
+        source_url: Optional source URL for the figure (must be unique)
 
     Returns:
         dict: Figure information from the API
@@ -180,8 +148,7 @@ def _create_or_get_figure(
     if not ephemeral and api_key is None:
         raise ValueError("API key is required for non-ephemeral figures")
 
-    payload = {
-        "figureHash": figure_hash,
+    payload: dict[str, Union[str, int]] = {
         "figpackVersion": __version__,
         "bucket": FIGPACK_BUCKET,
     }
@@ -198,6 +165,8 @@ def _create_or_get_figure(
         payload["title"] = title
     if ephemeral:
         payload["ephemeral"] = True
+    if source_url is not None:
+        payload["sourceUrl"] = source_url
 
     # Use the same endpoint for both regular and ephemeral figures
     response = requests.post(f"{FIGPACK_API_BASE_URL}/api/figures/create", json=payload)
@@ -208,12 +177,12 @@ def _create_or_get_figure(
             error_msg = error_data.get("message", "Unknown error")
         except:
             error_msg = f"HTTP {response.status_code}"
-        raise Exception(f"Failed to create figure {figure_hash}: {error_msg}")
+        raise Exception(f"Failed to create figure: {error_msg}")
 
     response_data = response.json()
     if not response_data.get("success"):
         raise Exception(
-            f"Failed to create figure {figure_hash}: {response_data.get('message', 'Unknown error')}"
+            f"Failed to create figure: {response_data.get('message', 'Unknown error')}"
         )
 
     return response_data
@@ -254,10 +223,11 @@ def _finalize_figure(figure_url: str, api_key: str) -> dict:
 
 def _upload_bundle(
     tmpdir: str,
-    api_key: str,
-    title: str = None,
+    api_key: Optional[str],
+    title: Optional[str] = None,
     ephemeral: bool = False,
     use_consolidated_metadata_only: bool = False,
+    source_url: Optional[str] = None,
 ) -> str:
     """
     Upload the prepared bundle to the cloud using the new database-driven approach
@@ -269,12 +239,10 @@ def _upload_bundle(
         ephemeral: Whether to create an ephemeral figure
         use_consolidated_metadata_only: If True, excludes individual zarr metadata files
             (.zgroup, .zarray, .zattrs) since they are included in .zmetadata
+        source_url: Optional source URL for the figure (must be unique)
     """
     tmpdir_path = pathlib.Path(tmpdir)
 
-    # Compute deterministic figure ID based on file contents
-    figure_hash = _compute_deterministic_figure_hash(tmpdir_path)
-
     # Collect all files to upload
     all_files = []
     for file_path in tmpdir_path.rglob("*"):
@@ -295,7 +263,12 @@ def _upload_bundle(
 
     # Find available figure ID and create/get figure in database with metadata
     result = _create_or_get_figure(
-        figure_hash, api_key, total_files, total_size, title=title, ephemeral=ephemeral
+        api_key,
+        total_files,
+        total_size,
+        title=title,
+        ephemeral=ephemeral,
+        source_url=source_url,
     )
     figure_info = result.get("figure", {})
     figure_url = figure_info.get("figureUrl")
@@ -331,7 +304,9 @@ def _upload_bundle(
 
             # Get signed URLs for this batch
             try:
-                signed_urls_map = _get_batch_signed_urls(figure_url, batch, api_key)
+                signed_urls_map = _get_batch_signed_urls(
+                    figure_url, batch, api_key if api_key else ""
+                )
             except Exception as e:
                 print(f"Failed to get signed URLs for batch {batch_num}: {e}")
                 raise
@@ -402,7 +377,9 @@ def _upload_bundle(
     try:
         # Use batch API for manifest
         manifest_batch = [("manifest.json", temp_file_path)]
-        signed_urls_map = _get_batch_signed_urls(figure_url, manifest_batch, api_key)
+        signed_urls_map = _get_batch_signed_urls(
+            figure_url, manifest_batch, api_key if api_key else ""
+        )
 
         if "manifest.json" not in signed_urls_map:
             raise Exception("No signed URL returned for manifest.json")
@@ -420,12 +397,45 @@ def _upload_bundle(
 
     # Finalize the figure upload
     print("Finalizing figure...")
-    _finalize_figure(figure_url, api_key)
+    _finalize_figure(figure_url, api_key if api_key else "")
     print("Upload completed successfully")
 
     return figure_url
 
 
+def get_figure_by_source_url(source_url: str) -> Optional[str]:
+    """
+    Query the API for a figure URL by its source URL
+
+    Args:
+        source_url: The source URL to search for
+
+    Returns:
+        Optional[str]: The figure URL if found, None otherwise
+    """
+    payload = {"sourceUrl": source_url}
+
+    response = requests.post(
+        f"{FIGPACK_API_BASE_URL}/api/figures/find-by-source-url", json=payload
+    )
+
+    if not response.ok:
+        if response.status_code == 404:
+            return None
+        try:
+            error_data = response.json()
+            error_msg = error_data.get("message", "Unknown error")
+        except:
+            error_msg = f"HTTP {response.status_code}"
+        raise Exception(f"Failed to query figure by source URL: {error_msg}")
+
+    response_data = response.json()
+    if not response_data.get("success"):
+        return None
+
+    return response_data.get("figureUrl")
+
+
 def _determine_content_type(file_path: str) -> str:
     """
     Determine content type for upload based on file extension

figpack/core/_view_figure.py

@@ -11,7 +11,7 @@ import threading
 import webbrowser
 from typing import Union
 
-from ._server_manager import CORSRequestHandler, ThreadingHTTPServer
+from ._server_manager import ProcessServerManager
 
 
 def serve_files(
@@ -20,35 +20,71 @@ def serve_files(
     port: Union[int, None],
     open_in_browser: bool = False,
     allow_origin: Union[str, None] = None,
+    enable_file_upload: bool = False,
+    max_file_size: int = 10 * 1024 * 1024,
 ):
     """
-    Serve files from a directory using a simple HTTP server.
+    Serve files from a directory using the ProcessServerManager.
 
     Args:
         tmpdir: Directory to serve
         port: Port number for local server
         open_in_browser: Whether to open in browser automatically
         allow_origin: CORS allow origin header
+        enable_file_upload: Whether to enable PUT requests for file uploads
+        max_file_size: Maximum file size in bytes for uploads (default 10MB)
     """
+    tmpdir_2 = pathlib.Path(tmpdir)
+    tmpdir_2 = tmpdir_2.resolve()
+    if not tmpdir_2.exists() or not tmpdir_2.is_dir():
+        raise SystemExit(f"Directory not found: {tmpdir_2}")
+
+    # Create a temporary server manager instance for this specific directory
+    # Note: We can't use the singleton ProcessServerManager here because it serves
+    # from its own temp directory, but we need to serve from the specified tmpdir
+
+    # Import the required classes for direct server creation
+    from ._server_manager import CORSRequestHandler, ThreadingHTTPServer
+    from ._file_handler import FileUploadCORSRequestHandler
+
     # if port is None, find a free port
     if port is None:
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
             s.bind(("", 0))
             port = s.getsockname()[1]
 
-    tmpdir = pathlib.Path(tmpdir)
-    tmpdir = tmpdir.resolve()
-    if not tmpdir.exists() or not tmpdir.is_dir():
-        raise SystemExit(f"Directory not found: {tmpdir}")
+    # Choose handler based on file upload requirement
+    if enable_file_upload:
+
+        def handler_factory_upload_enabled(*args, **kwargs):
+            return FileUploadCORSRequestHandler(
+                *args,
+                directory=str(tmpdir_2),
+                allow_origin=allow_origin,
+                enable_file_upload=True,
+                max_file_size=max_file_size,
+                **kwargs,
+            )
 
-    # Configure handler with directory and allow_origin
-    def handler_factory(*args, **kwargs):
-        return CORSRequestHandler(
-            *args, directory=str(tmpdir), allow_origin=allow_origin, **kwargs
+        upload_status = (
+            " (file upload enabled)" if handler_factory_upload_enabled else ""
         )
 
-    httpd = ThreadingHTTPServer(("0.0.0.0", port), handler_factory)
-    print(f"Serving {tmpdir} at http://localhost:{port} (CORS → {allow_origin})")
+        httpd = ThreadingHTTPServer(("0.0.0.0", port), handler_factory_upload_enabled)  # type: ignore
+    else:
+
+        def handler_factory(*args, **kwargs):
+            return CORSRequestHandler(
+                *args, directory=str(tmpdir_2), allow_origin=allow_origin, **kwargs
+            )
+
+        upload_status = ""
+
+        httpd = ThreadingHTTPServer(("0.0.0.0", port), handler_factory)  # type: ignore
+
+    print(
+        f"Serving {tmpdir_2} at http://localhost:{port} (CORS → {allow_origin}){upload_status}"
+    )
     thread = threading.Thread(target=httpd.serve_forever, daemon=True)
     thread.start()