perspective-python 3.0.0__cp39-abi3-macosx_13_0_x86_64.whl

perspective/__init__.py

@@ -0,0 +1,81 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+__version__ = "3.0.0"
+__all__ = [
+    "_jupyter_labextension_paths",
+    "PerspectiveError",
+    "PerspectiveWidget",
+    "PerspectiveViewer",
+    "PerspectiveTornadoHandler",
+    "ProxySession",
+    "Table",
+    "View",
+    "Server",
+    "Client",
+]
+
+from .perspective import (
+    Client as PySyncClient,
+    PerspectiveError,
+    Table,
+    View,
+    ProxySession,
+)
+
+from .widget import PerspectiveWidget
+from .viewer import PerspectiveViewer
+
+from .psp_cffi import ServerBase
+
+try:
+    from .handlers import PerspectiveTornadoHandler
+except ImportError:
+    ...
+
+
+def default_loop_cb(fn, *args, **kwargs):
+    return fn(*args, **kwargs)
+
+
+class Server(ServerBase):
+    def set_threadpool_size(self, n_cpus):
+        pass
+
+    def new_local_client(self, loop_callback=default_loop_cb):
+        """Create a new `Client` instance bound to this in-process `Server`."""
+        return Client.from_server(self, loop_callback)
+
+
+class Client(PySyncClient):
+    def from_server(
+        server: Server,
+        loop_callback=default_loop_cb,
+    ):
+        """Create a new `Client` instance bound synchronously to an Python
+        instance of `PerspectiveServer`."""
+
+        def handle_request(bytes):
+            session.handle_request(bytes)
+            loop_callback(lambda: session.poll())
+
+        def handle_response(bytes):
+            client.handle_response(bytes)
+
+        session = server.new_session(handle_response)
+        client = Client(handle_request)
+        return client
+
+
+# Read by `jupyter labextension develop`
+def _jupyter_labextension_paths():
+    return [{"src": "labextension", "dest": "@finos/perspective-jupyterlab"}]

perspective/extension/finos-perspective-nbextension.json

@@ -0,0 +1,5 @@
+{
+    "load_extensions": {
+        "@finos/perspective-jupyterlab/extension": true
+    }
+}

perspective/handlers/__init__.py

@@ -0,0 +1,26 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+try:
+    from .aiohttp import PerspectiveAIOHTTPHandler  # noqa: F401
+except ImportError:
+    ...
+
+try:
+    from .starlette import PerspectiveStarletteHandler  # noqa: F401
+except ImportError:
+    ...
+
+try:
+    from .tornado import PerspectiveTornadoHandler  # noqa: F401
+except ImportError:
+    ...

perspective/handlers/aiohttp.py

@@ -0,0 +1,54 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+from aiohttp import web, WSMsgType
+import asyncio
+
+
+class PerspectiveAIOHTTPHandler(object):
+    """PerspectiveAIOHTTPHandler is a drop-in implementation of Perspective.
+
+    Use it inside AIOHTTP routing to create a server-side Perspective that is
+    ready to receive websocket messages from the front-end `perspective-viewer`.
+
+    The Perspective client and server will automatically keep the Websocket
+    alive without timing out.
+
+    Examples:
+        >>> server = Server()
+        >>> async def websocket_handler(request):
+        ...    handler = PerspectiveAIOHTTPHandler(perspective_server=server, request=request)
+        ...    await handler.run()
+
+        >>> app = web.Application()
+        >>> app.router.add_get("/websocket", websocket_handler)
+    """
+
+    def __init__(self, **kwargs):
+        self.server = kwargs.pop("perspective_server")
+        self._request = kwargs.pop("request")
+        super().__init__(**kwargs)
+
+    async def run(self) -> None:
+        def inner(msg):
+            asyncio.get_running_loop().create_task(self._ws.send_bytes(msg))
+
+        self.session = self.server.new_session(inner)
+        try:
+            self._ws = web.WebSocketResponse()
+            await self._ws.prepare(self._request)
+            async for msg in self._ws:
+                if msg.type == WSMsgType.BINARY:
+                    self.session.handle_request(msg.data)
+
+        finally:
+            self.session.close()

perspective/handlers/starlette.py

@@ -0,0 +1,51 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+import asyncio
+
+
+class PerspectiveStarletteHandler(object):
+    """PerspectiveStarletteHandler is a drop-in implementation of Perspective.
+
+    The Perspective client and server will automatically keep the Websocket
+    alive without timing out.
+
+    Examples:
+        >>> server = Server()
+        >>> client = server.client()
+        >>> client.table(pd.read_csv("superstore.csv"), name="data_source_one")
+        >>> app = FastAPI()
+        >>> async def endpoint(websocket: Websocket):
+        ...     handler = PerspectiveStarletteHandler(server, websocket)
+        ...     await handler.run()
+        ... app.add_api_websocket_route('/websocket', endpoint)
+    """
+
+    def __init__(self, **kwargs):
+        self._server = kwargs.pop("perspective_server")
+        self._websocket = kwargs.pop("websocket")
+        super().__init__(**kwargs)
+
+    async def run(self) -> None:
+        def inner(msg):
+            asyncio.get_running_loop().create_task(self._websocket.send_bytes(msg))
+
+        self.session = self._server.new_session(inner)
+
+        try:
+            await self._websocket.accept()
+            while True:
+                message = await self._websocket.receive()
+                self._websocket._raise_on_disconnect(message)
+                self.session.handle_request(message["bytes"])
+        finally:
+            self.session.close()

perspective/handlers/tornado.py

@@ -0,0 +1,61 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+from tornado.websocket import WebSocketHandler
+
+
+class PerspectiveTornadoHandler(WebSocketHandler):
+    """PerspectiveTornadoHandler is a drop-in implementation of Perspective.
+
+    Use it inside Tornado routing to create a server-side Perspective that is
+    ready to receive websocket messages from the front-end `perspective-viewer`.
+    Because Tornado implements an event loop, this handler links Perspective
+    with `IOLoop.current()` in order to defer expensive operations until the
+    next free iteration of the event loop.
+
+    The Perspective client and server will automatically keep the Websocket
+    alive without timing out.
+
+    Examples:
+        >>> server = psp.Server()
+        >>> client = server.new_local_client()
+        >>> client.table(pd.read_csv("superstore.csv"), name="data_source_one")
+        >>> app = tornado.web.Application([
+        ...     (r"/", MainHandler),
+        ...     (r"/websocket", PerspectiveTornadoHandler, {
+        ...         "perspective_server": server,
+        ...         "check_origin": True
+        ...     })
+        ... ])
+    """
+
+    def initialize(self, perspective_server):
+        self.server = perspective_server
+
+    def open(self):
+        def inner(msg):
+            self.write_message(msg, binary=True)
+
+        self.session = self.server.new_session(inner)
+
+    def on_close(self) -> None:
+        self.session.close()
+        del self.session
+
+    def on_message(self, msg: bytes):
+        if not isinstance(msg, bytes):
+            return
+
+        self.session.handle_request(msg)
+
+        # TODO schedule me
+        self.session.poll()

perspective/psp_cffi.py

@@ -0,0 +1,127 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+import ctypes
+import os
+import platform
+from typing import Callable
+
+if "PSP_CXX_SO_PATH" in os.environ:
+    lib = ctypes.CDLL(os.environ["PSP_CXX_SO_PATH"])
+else:
+    ext = "so"
+    if platform.system().lower() == "windows":
+        ext = "dll"
+    arch = platform.machine().lower()
+    if arch == "amd64":
+        arch = "x86_64"
+    dylib_name = f"{platform.system().lower()}-{arch}-libpsp.{ext}"
+    lib = ctypes.CDLL(os.path.join(os.path.dirname(__file__), dylib_name))
+
+
+class EncodedApiResp(ctypes.Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("data", ctypes.POINTER(ctypes.c_char)),
+        ("size", ctypes.c_uint32),
+        ("client_id", ctypes.c_uint32),
+    ]
+
+
+class EncodedApiEntries(ctypes.Structure):
+    _pack_ = 1
+    _fields_ = [
+        ("size", ctypes.c_uint32),
+        ("entries", ctypes.POINTER(EncodedApiResp)),
+    ]
+
+
+ProtoApiServerPtr = ctypes.c_void_p
+lib.psp_new_server.restype = ProtoApiServerPtr
+
+lib.psp_new_session.argtypes = [ProtoApiServerPtr]
+lib.psp_new_session.restype = ctypes.c_uint32
+
+lib.psp_handle_request.argtypes = [
+    ProtoApiServerPtr,
+    ctypes.c_uint32,
+    ctypes.c_char_p,
+    ctypes.c_size_t,
+]
+lib.psp_handle_request.restype = ctypes.POINTER(EncodedApiEntries)
+
+lib.psp_poll.argtypes = [ProtoApiServerPtr]
+lib.psp_poll.restype = ctypes.POINTER(EncodedApiEntries)
+
+lib.psp_new_session.argtypes = [ProtoApiServerPtr]
+lib.psp_new_session.restype = ctypes.c_uint32
+
+lib.psp_close_session.argtypes = [ProtoApiServerPtr, ctypes.c_uint32]
+lib.psp_close_session.restype = None
+
+lib.psp_delete_server.argtypes = [ProtoApiServerPtr]
+lib.psp_delete_server.restype = None
+
+
+class Session:
+    def __init__(self, server: "ServerBase"):
+        self._server: "ServerBase" = server
+        self._session_id = lib.psp_new_session(server._server)
+
+    def __del__(self):
+        lib.psp_close_session(self._server._server, self._session_id)
+
+    def handle_request(self, bytes_msg):
+        resps = lib.psp_handle_request(
+            self._server._server, self._session_id, bytes_msg, len(bytes_msg)
+        )
+        try:
+            size = resps.contents.size
+            for i in range(size):
+                resp = resps.contents.entries[i]
+                self._server._client_cbs[resp.client_id](resp.data[: resp.size])
+        finally:
+            for i in range(size):
+                lib.psp_free(resps.contents.entries[i].data)
+            lib.psp_free(resps.contents.entries)
+            lib.psp_free(resps)
+
+    def poll(self):
+        resps = lib.psp_poll(self._server._server)
+        try:
+            size = resps.contents.size
+            for i in range(size):
+                resp = resps.contents.entries[i]
+                self._server._client_cbs[resp.client_id](resp.data[: resp.size])
+        finally:
+            for i in range(size):
+                lib.psp_free(resps.contents.entries[i].data)
+            lib.psp_free(resps.contents.entries)
+            lib.psp_free(resps)
+
+
+class ServerBase:
+    def __init__(self):
+        self._client_cbs: dict[str, Callable[[bytes], None]] = {}
+        self._sessions: list[Session] = []
+        self._server: int = lib.psp_new_server()
+
+    def __del__(self):
+        for session in self._sessions:
+            del session
+        lib.psp_delete_server(self._server)
+
+    def new_session(self, cb: Callable[[bytes], None]):
+        session = Session(self)
+        self._client_cbs[session._session_id] = cb
+        self._sessions.append(session)
+        return session

perspective/templates/exported_widget.html.jinja

@@ -0,0 +1,35 @@
+<script type="module" src="{{ psp_cdn('perspective') }}"></script>
+<script type="module" src="{{ psp_cdn('perspective-viewer') }}"></script>
+<script type="module" src="{{ psp_cdn('perspective-viewer-datagrid') }}"></script>
+<script type="module" src="{{ psp_cdn('perspective-viewer-d3fc') }}"></script>
+<link rel="stylesheet" crossorigin="anonymous" href="{{ psp_cdn('perspective-viewer', 'css/pro.css') }}" />
+
+<div class="perspective-envelope" id="perspective-envelope-{{viewer_id}}">
+    <script type="application/vnd.apache.arrow.file">
+    {{ b64_data }}
+    </script>
+    <perspective-viewer style="height: 690px;"></perspective-viewer>
+    <script type="module">
+        // from MDN
+        function base64ToBytes(base64) {
+            const binString = atob(base64);
+            return Uint8Array.from(binString, (m) => m.codePointAt(0));
+        }
+
+        import * as perspective from "{{ psp_cdn('perspective') }}";
+        const viewerId = {{ viewer_id | tojson }};
+        const currentScript = document.scripts[document.scripts.length - 1];
+        const envelope = document.getElementById(`perspective-envelope-${viewerId}`);
+        const dataScript = envelope.querySelector('script[type="application/vnd.apache.arrow.file"]');;
+        if (!dataScript)
+            throw new Error('data script missing for viewer', viewerId);
+        const data = base64ToBytes(dataScript.textContent);
+        const viewerAttrs = {{ viewer_attrs | tojson }};
+
+        // Create a new worker, then a new table promise on that worker.
+        const table = await perspective.worker().table(data.buffer);
+        const viewer = envelope.querySelector('perspective-viewer');
+        viewer.load(table);
+        viewer.restore(viewerAttrs);
+    </script>
+</div>

perspective/tests/__init__.py

@@ -0,0 +1,11 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛