perspective-python 3.0.0rc1__cp39-abi3-win_amd64.whl

perspective/__init__.py

@@ -0,0 +1,78 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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-rc.1"
+__all__ = [
+    "_jupyter_labextension_paths",
+    "PerspectiveError",
+    "PerspectiveWidget",
+    "PerspectiveViewer",
+    "PerspectiveTornadoHandler",
+    "Table",
+    "View",
+]
+
+from .perspective import (
+    PySyncClient,
+    PerspectiveError,
+    PySyncServer,
+    Table,
+    View,
+    PySyncProxySession as ProxySession,
+)
+
+from .widget import PerspectiveWidget
+from .viewer import PerspectiveViewer
+
+
+try:
+    from .handlers import PerspectiveTornadoHandler
+except ImportError:
+    ...
+
+
+def default_loop_cb(fn, *args, **kwargs):
+    return fn(*args, **kwargs)
+
+
+class Server(PySyncServer):
+    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
+except ImportError:
+    ...
+
+try:
+    from .starlette import PerspectiveStarletteHandler
+except ImportError:
+    ...
+
+try:
+    from .tornado import PerspectiveTornadoHandler
+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/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). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

perspective/tests/conftest.py

@@ -0,0 +1,268 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 datetime import datetime, date
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from pytest import fixture
+from random import random, randint, choice
+from faker import Faker
+
+
+fake = Faker()
+
+# Our tests construct naive datetimes everywhere
+# so setting it here is an easy way to fix it globally.
+import os
+os.environ["TZ"] = "UTC"
+
+def _make_date_time_index(size, time_unit):
+    return pd.date_range("2000-01-01", periods=size, freq=time_unit)
+
+
+def _make_period_index(size, time_unit):
+    return pd.period_range(start="2000", periods=size, freq=time_unit)
+
+
+def _make_dataframe(index, size=10):
+    """Create a new random dataframe of `size` and with a DateTimeIndex of
+    frequency `time_unit`.
+    """
+    return pd.DataFrame(
+        index=index,
+        data={
+            "a": np.random.rand(size),
+            "b": np.random.rand(size),
+            "c": np.random.rand(size),
+            "d": np.random.rand(size),
+        },
+    )
+
+
+class Util:
+    @staticmethod
+    def make_arrow(names, data, types=None, legacy=False):
+        """Create an arrow binary that can be loaded and manipulated from memory.
+
+        Args:
+            names (list): a list of str column names
+            data (list): a list of lists containing data for each column
+            types (list): an optional list of `pyarrow.type` function references.
+                Types will be inferred if not provided.
+            legacy (bool): if True, use legacy IPC format (pre-pyarrow 0.15). Defaults to False.
+
+        Returns:
+            bytes : a bytes object containing the arrow-serialized output.
+        """
+        stream = pa.BufferOutputStream()
+        arrays = []
+
+        for idx, column in enumerate(data):
+            # only apply types if array is present
+            kwargs = {}
+            if types:
+                kwargs["type"] = types[idx]
+            arrays.append(pa.array(column, **kwargs))
+
+        batch = pa.RecordBatch.from_arrays(arrays, names)
+        table = pa.Table.from_batches([batch])
+        writer = pa.RecordBatchStreamWriter(
+            stream, table.schema, use_legacy_format=legacy
+        )
+
+        writer.write_table(table)
+        writer.close()
+        return stream.getvalue().to_pybytes()
+
+    @staticmethod
+    def make_arrow_from_pandas(df, schema=None, legacy=False):
+        """Create an arrow binary from a Pandas dataframe.
+
+        Args:
+            df (:obj:`pandas.DataFrame`)
+            schema (:obj:`pyarrow.Schema`)
+            legacy (bool): if True, use legacy IPC format (pre-pyarrow 0.15). Defaults to False.
+
+        Returns:
+            bytes : a bytes object containing the arrow-serialized output.
+        """
+        stream = pa.BufferOutputStream()
+        table = pa.Table.from_pandas(df, schema=schema)
+
+        writer = pa.RecordBatchStreamWriter(
+            stream, table.schema, use_legacy_format=legacy
+        )
+
+        writer.write_table(table)
+        writer.close()
+        return stream.getvalue().to_pybytes()
+
+    @staticmethod
+    def make_dictionary_arrow(names, data, types=None, legacy=False):
+        """Create an arrow binary that can be loaded and manipulated from memory, with
+        each column being a dictionary array of `str` values and `int` indices.
+
+        Args:
+            names (list): a list of str column names
+            data (list:tuple): a list of tuples, the first value being a list of indices,
+                and the second value being a list of values.
+            types (list:list:pyarrow.func): a list of lists, containing the indices type and
+                dictionary value type for each array.
+            legacy (bool): if True, use legacy IPC format (pre-pyarrow 0.15). Defaults to False.
+
+        Returns:
+            bytes : a bytes object containing the arrow-serialized output.
+        """
+        stream = pa.BufferOutputStream()
+
+        arrays = []
+        for idx, column in enumerate(data):
+            indice_type = pa.int64()
+            value_type = pa.string()
+
+            if types is not None:
+                indice_type = types[idx][0]
+                value_type = types[idx][1]
+
+            indices = pa.array(column[0], type=indice_type)
+            values = pa.array(column[1], type=value_type)
+            parray = pa.DictionaryArray.from_arrays(indices, values)
+            arrays.append(parray)
+
+        batch = pa.RecordBatch.from_arrays(arrays, names)
+        table = pa.Table.from_batches([batch])
+        writer = pa.RecordBatchStreamWriter(
+            stream, table.schema, use_legacy_format=legacy
+        )
+
+        writer.write_table(table)
+        writer.close()
+        return stream.getvalue().to_pybytes()
+
+    @staticmethod
+    def to_timestamp(obj):
+        """Return an integer timestamp based on a date/datetime object."""
+        classname = obj.__class__.__name__
+        if classname == "date":
+            return int(datetime(obj.year, obj.month, obj.day).timestamp() * 1000)
+        elif classname == "datetime":
+            return int(obj.timestamp() * 1000)
+        else:
+            return -1
+
+    @staticmethod
+    def make_dataframe(size=10, freq="D"):
+        index = _make_date_time_index(size, freq)
+        return _make_dataframe(index, size)
+
+    @staticmethod
+    def make_period_dataframe(size=10):
+        index = _make_period_index(size, "M")
+        return _make_dataframe(index, size)
+
+    @staticmethod
+    def make_series(size=10, freq="D"):
+        index = _make_date_time_index(size, freq)
+        return pd.Series(data=np.random.rand(size), index=index)
+
+
+class Sentinel(object):
+    """Generic sentinel class for testing side-effectful code in Python 2 and
+    3.
+    """
+
+    def __init__(self, value):
+        self.value = value
+
+    def get(self):
+        return self.value
+
+    def set(self, new_value):
+        self.value = new_value
+
+
+@fixture()
+def sentinel():
+    """Pass `sentinel` into a test and call it with `value` to create a new
+    instance of the Sentinel class.
+
+    Example:
+        >>> def test_with_sentinel(self, sentinel):
+        >>>    s = sentinel(True)
+        >>>    s.set(False)
+        >>>    s.get()  # returns False
+    """
+
+    def _sentinel(value):
+        return Sentinel(value)
+
+    return _sentinel
+
+
+@fixture
+def util():
+    """Pass the `Util` class in to a test."""
+    return Util
+
+
+@fixture
+def superstore(count=100):
+    data = []
+    for id in range(count):
+        dat = {}
+        dat["Row ID"] = id
+        dat["Order ID"] = "{}-{}".format(fake.ein(), fake.zipcode())
+        dat["Order Date"] = fake.date_this_year()
+        dat["Ship Date"] = fake.date_between_dates(dat["Order Date"]).strftime(
+            "%Y-%m-%d"
+        )
+        dat["Order Date"] = dat["Order Date"].strftime("%Y-%m-%d")
+        dat["Ship Mode"] = choice(["First Class", "Standard Class", "Second Class"])
+        dat["Ship Mode"] = choice(["First Class", "Standard Class", "Second Class"])
+        dat["Customer ID"] = fake.zipcode()
+        dat["Segment"] = choice(["A", "B", "C", "D"])
+        dat["Country"] = "US"
+        dat["City"] = fake.city()
+        dat["State"] = fake.state()
+        dat["Postal Code"] = fake.zipcode()
+        dat["Region"] = choice(["Region %d" % i for i in range(5)])
+        dat["Product ID"] = fake.bban()
+        sector = choice(["Industrials", "Technology", "Financials"])
+        industry = choice(["A", "B", "C"])
+        dat["Category"] = sector
+        dat["Sub-Category"] = industry
+        dat["Sales"] = randint(1, 100) * 100
+        dat["Quantity"] = randint(1, 100) * 10
+        dat["Discount"] = round(random() * 100, 2)
+        dat["Profit"] = round(random() * 1000, 2)
+        data.append(dat)
+    return pd.DataFrame(data)
+
+
+# Perspective used to support datetime.date and datetime.datetime
+# as Table() constructor arguments, but now we forward the parameters
+# directly to JSON.loads. So to make sure the tests dont need to be
+# so utterly transmogrified, we have this little hack :)
+import json
+old = json.JSONEncoder.default
+
+def new_encoder(self, obj):
+    if isinstance(obj, datetime):
+        return str(obj)
+    elif isinstance(obj, date):
+        return str(obj)
+    else:
+        return old(self, obj)
+
+json.JSONEncoder.default = new_encoder

perspective/tests/core/__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). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛