Spacelab 0.28.0__py3-none-any.whl

spacelab/server.py

@@ -0,0 +1,130 @@
+"""Static server mirroring server.js: the bundled frontend first, then the data dir."""
+
+import json
+import mimetypes
+import os
+import re
+import sys
+import time
+from functools import partial
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+STATIC_DIR = Path(__file__).parent / "static"
+ZARR_METADATA = (".zarray", ".zattrs", ".zgroup")
+# One range only (what the app sends); a multi-range request gets the whole file.
+_RANGE = re.compile(r"bytes=(\d*)-(\d*)$")
+_COPY_CHUNK = 64 * 1024
+_START = time.time()
+
+
+class Handler(SimpleHTTPRequestHandler):
+    def __init__(self, *args, data_dir: str, **kwargs):
+        self.data_dir = data_dir
+        super().__init__(*args, directory=str(STATIC_DIR), **kwargs)
+
+    def translate_path(self, path):
+        # Frontend assets win; anything else resolves against the data dir.
+        static = super().translate_path(path)
+        if os.path.exists(static):
+            return static
+        rel = os.path.relpath(static, STATIC_DIR)
+        return os.path.join(self.data_dir, rel)
+
+    def guess_type(self, path):
+        if str(path).endswith(ZARR_METADATA):
+            return "application/json"
+        return super().guess_type(path)
+
+    def end_headers(self):
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS")
+        self.send_header(
+            "Access-Control-Allow-Headers",
+            "Origin, X-Requested-With, Content-Type, Accept, Range",
+        )
+        self.send_header("Access-Control-Expose-Headers", "Content-Length, Content-Range")
+        self.send_header("Cache-Control", "no-cache")
+        super().end_headers()
+
+    def do_OPTIONS(self):
+        self.send_response(204)
+        self.end_headers()
+
+    # Byte ranges, as express.static serves them: the SpatialData reader fetches
+    # parquet footers and single row groups by range, and a 200 with the whole
+    # file instead makes it pull a multi-GB transcripts part into the browser.
+    def send_head(self):
+        self._range_remaining = None
+        header = self.headers.get("Range")
+        path = self.translate_path(self.path)
+        match = _RANGE.match(header.strip()) if header else None
+        if not match or not (match[1] or match[2]) or not os.path.isfile(path):
+            return super().send_head()
+
+        size = os.path.getsize(path)
+        if match[1]:
+            start = int(match[1])
+            end = min(int(match[2]), size - 1) if match[2] else size - 1
+        else:  # suffix range: the last N bytes
+            start, end = max(0, size - int(match[2])), size - 1
+        if start >= size or start > end:
+            self.send_response(416)
+            self.send_header("Content-Range", f"bytes */{size}")
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+            return None
+
+        f = open(path, "rb")
+        f.seek(start)
+        self.send_response(206)
+        self.send_header("Content-Type", self.guess_type(path))
+        self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
+        self.send_header("Content-Length", str(end - start + 1))
+        self.send_header("Accept-Ranges", "bytes")
+        self.end_headers()
+        self._range_remaining = end - start + 1
+        return f
+
+    def copyfile(self, source, outputfile):
+        remaining = getattr(self, "_range_remaining", None)
+        if remaining is None:
+            return super().copyfile(source, outputfile)
+        while remaining > 0:
+            buf = source.read(min(_COPY_CHUNK, remaining))
+            if not buf:
+                break
+            outputfile.write(buf)
+            remaining -= len(buf)
+
+    def do_GET(self):
+        if self.path == "/health":
+            body = json.dumps({"status": "healthy", "uptime": time.time() - _START}).encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            return
+        super().do_GET()
+
+    def log_message(self, format, *args):
+        pass  # per-chunk request logs would flood the terminal
+
+
+class Server(ThreadingHTTPServer):
+    daemon_threads = True
+
+    def handle_error(self, request, client_address):
+        # The app aborts in-flight fetches (tiles on pan/zoom, chunks on tissue
+        # switch); the resulting resets are routine, not worth a traceback.
+        if isinstance(sys.exc_info()[1], (ConnectionResetError, BrokenPipeError)):
+            return
+        super().handle_error(request, client_address)
+
+
+def make_server(data_dir: str, host: str, port: int) -> ThreadingHTTPServer:
+    mimetypes.add_type("application/javascript", ".js")
+    mimetypes.add_type("application/wasm", ".wasm")
+    handler = partial(Handler, data_dir=os.path.abspath(data_dir))
+    return Server((host, port), handler)