perspective-python 3.0.0rc1__cp39-abi3-win_amd64.whl

perspective/widget/widget.py

@@ -0,0 +1,269 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 base64
+import jinja2
+import json
+import logging
+import os
+from datetime import date, datetime
+from functools import partial
+
+from ipywidgets import DOMWidget
+from traitlets import Unicode, observe
+from ..viewer import PerspectiveViewer
+import importlib
+
+__version__ = importlib.metadata.version("perspective-python")
+
+
+class PerspectiveWidget(DOMWidget, PerspectiveViewer):
+    """:class`~perspective.PerspectiveWidget` allows for Perspective to be used
+    in the form of a Jupyter IPython widget.
+
+    Using `perspective.Table`, you can create a widget that extends the full
+    functionality of `perspective-viewer`.  Changes on the viewer can be
+    programatically set on the :class`~perspective.PerspectiveWidget` instance,
+    and state is maintained across page refreshes.
+
+    Examples:
+        >>> from perspective import Table, PerspectiveWidget
+        >>> data = {
+        ...     "a": [1, 2, 3],
+        ...     "b": [
+        ...         "2019/07/11 7:30PM",
+        ...         "2019/07/11 8:30PM",
+        ...         "2019/07/11 9:30PM"
+        ...     ]
+        ... }
+        >>> tbl = Table(data, index="a")
+        >>> widget = PerspectiveWidget(
+        ...     tbl,
+        ...     group_by=["a"],
+        ...     sort=[["b", "desc"]],
+        ...     filter=[["a", ">", 1]]
+        ... )
+        >>> widget.sort
+        [["b", "desc"]]
+        >>> widget.sort.append(["a", "asc"])
+        >>> widget.sort
+        [["b", "desc"], ["a", "asc"]]
+        >>> widget.update({"a": [4, 5]}) # Browser UI updates
+    """
+
+    # Required by ipywidgets for proper registration of the backend
+    _model_name = Unicode("PerspectiveModel").tag(sync=True)
+    _model_module = Unicode("@finos/perspective-jupyterlab").tag(sync=True)
+    _model_module_version = Unicode("~{}".format(__version__)).tag(sync=True)
+    _view_name = Unicode("PerspectiveView").tag(sync=True)
+    _view_module = Unicode("@finos/perspective-jupyterlab").tag(sync=True)
+    _view_module_version = Unicode("~{}".format(__version__)).tag(sync=True)
+
+    def __init__(
+        self,
+        data,
+        index=None,
+        limit=None,
+        binding_mode="server",
+        **kwargs,
+    ):
+        """Initialize an instance of :class`~perspective.PerspectiveWidget`
+        with the given table/data and viewer configuration.
+
+        If a pivoted DataFrame or MultiIndex table is passed in, the widget
+        preserves pivots and applies them.  See `PerspectiveViewer.__init__` for
+        arguments that transform the view shown in the widget.
+
+        Args:
+            data (:obj:`Table`|:obj:`View`|:obj:`dict`|:obj:`list`|:obj:`pandas.DataFrame`|:obj:`bytes`|:obj:`str`): a
+                `perspective.Table` instance, a `perspective.View` instance, or
+                a dataset to be loaded in the widget.
+
+        Keyword Arguments:
+            index (:obj:`str`): A column name to be used as the primary key.
+                Ignored if `server` is True.
+
+            limit (:obj:`int`): A upper limit on the number of rows in the Table.
+                Cannot be set at the same time as `index`, ignored if `server`
+                is True.
+
+            binding_mode (:obj:`str`): "client-server" or "server"
+
+            kwargs (:obj:`dict`): configuration options for the `PerspectiveViewer`,
+                and `Table` constructor if `data` is a dataset.
+
+        Examples:
+            >>> widget = PerspectiveWidget(
+            ...     {"a": [1, 2, 3]},
+            ...     aggregates={"a": "avg"},
+            ...     group_by=["a"],
+            ...     sort=[["b", "desc"]],
+            ...     filter=[["a", ">", 1]],
+            ...     expressions=["\"a\" + 100"])
+        """
+
+        self.binding_mode = binding_mode
+
+        # Pass table load options to the front-end, unless in server mode
+        self._options = {}
+
+        if index is not None and limit is not None:
+            raise TypeError("Index and Limit cannot be set at the same time!")
+
+        # Parse the dataset we pass in - if it's Pandas, preserve pivots
+        # if isinstance(data, pandas.DataFrame) or isinstance(data, pandas.Series):
+        #     data, config = deconstruct_pandas(data)
+
+        #     if config.get("group_by", None) and "group_by" not in kwargs:
+        #         kwargs.update({"group_by": config["group_by"]})
+
+        #     if config.get("split_by", None) and "split_by" not in kwargs:
+        #         kwargs.update({"split_by": config["split_by"]})
+
+        #     if config.get("columns", None) and "columns" not in kwargs:
+        #         kwargs.update({"columns": config["columns"]})
+
+        # Initialize the viewer
+        super(PerspectiveWidget, self).__init__(**kwargs)
+
+        # Handle messages from the the front end
+        self.on_msg(self.handle_message)
+        self._sessions = {}
+
+        # If an empty dataset is provided, don't call `load()` and wait
+        # for the user to call `load()`.
+        if data is None:
+            if index is not None or limit is not None:
+                raise TypeError(
+                    "Cannot initialize PerspectiveWidget `index` or `limit` without a Table, data, or schema!"
+                )
+        else:
+            if index is not None:
+                self._options.update({"index": index})
+
+            if limit is not None:
+                self._options.update({"limit": limit})
+
+            self.load(data, **self._options)
+
+    def load(self, data, **options):
+        """Load the widget with data."""
+        # Viewer will ignore **options if `data` is a Table or View.
+        super(PerspectiveWidget, self).load(data, **options)
+
+    def update(self, data):
+        """Update the widget with new data."""
+        super(PerspectiveWidget, self).update(data)
+
+    def clear(self):
+        """Clears the widget's underlying `Table`."""
+        super(PerspectiveWidget, self).clear()
+
+    def replace(self, data):
+        """Replaces the widget's `Table` with new data conforming to the same
+        schema. Does not clear user-set state. If in client mode, serializes
+        the data and sends it to the browser.
+        """
+        super(PerspectiveWidget, self).replace(data)
+
+    def delete(self, delete_table=True):
+        """Delete the Widget's data and clears its internal state.
+
+        Args:
+            delete_table (`bool`): whether the underlying `Table` will be
+                deleted. Defaults to True.
+        """
+        super(PerspectiveWidget, self).delete(delete_table)
+
+        # Close the underlying comm and remove widget from the front-end
+        self.close()
+
+    @observe("value")
+    def handle_message(self, widget, content, buffers):
+        """Given a message from `PerspectiveJupyterClient.send()`, process the
+        message and return the result to `self.post`.
+
+        Args:
+            widget: a reference to the `Widget` instance that received the
+                message.
+            content (dict): the message from the front-end. Automatically
+                de-serialized by ipywidgets.
+            buffers : optional arraybuffers from the front-end, if any.
+        """
+        if content["type"] == "connect":
+            client_id = content["client_id"]
+            logging.debug("view {} connected", client_id)
+            self._sessions[client_id] = self.new_proxy_session(
+                lambda msg: self.send(
+                    {"type": "binary_msg", "client_id": client_id}, [msg]
+                )
+            )
+        elif content["type"] == "binary_msg":
+            [binary_msg] = buffers
+            client_id = content["client_id"]
+            session = self._sessions[client_id]
+            logging.debug("view {} message {}", client_id, len(binary_msg))
+            if session is not None:
+                session.handle_request(binary_msg)
+            else:
+                logging.error("No session for client_id {}".format(client_id))
+        elif content["type"] == "hangup":
+            # XXX(tom): client won't reliably send this so shouldn't rely on it to clean up; does jupyter notify us
+            # when the client on the websocket, i.e. the view, disconnects?
+            client_id = content["client_id"]
+            logging.debug("view {} hangup", client_id)
+            session = self._sessions.pop(client_id, None)
+            if session:
+                session.close()
+
+    def _repr_mimebundle_(self, **kwargs):
+        super_bundle = super(DOMWidget, self)._repr_mimebundle_(**kwargs)
+        if not _jupyter_html_export_enabled():
+            return super_bundle
+        # Serialize viewer attrs + view data to be rendered in the template
+        viewer_attrs = self.save()
+        data = self.table.view().to_arrow()
+        b64_data = base64.encodebytes(data)
+
+        jinja_env = jinja2.Environment(
+            loader=jinja2.PackageLoader("perspective"),
+            autoescape=jinja2.select_autoescape(),
+        )
+        template = jinja_env.get_template("exported_widget.html.jinja")
+
+        def psp_cdn(module, path=None):
+            if path is None:
+                path = f"cdn/{module}.js"
+            # perspective developer affordance: works with your local `pnpm run start blocks`
+            # return f"http://localhost:8080/node_modules/@finos/{module}/dist/{path}"
+            return f"https://cdn.jsdelivr.net/npm/@finos/{module}@{__version__}/dist/{path}"
+
+        return super(DOMWidget, self)._repr_mimebundle_(**kwargs) | {
+            "text/html": template.render(
+                psp_cdn=psp_cdn,
+                viewer_id=self.model_id,
+                viewer_attrs=viewer_attrs,
+                b64_data=b64_data.decode("utf-8"),
+            )
+        }
+
+
+def _jupyter_html_export_enabled():
+    return os.environ.get("PSP_JUPYTER_HTML_EXPORT", None) == "1"
+
+
+def set_jupyter_html_export(val):
+    """Enables HTML export for Jupyter widgets, when set to True.
+    HTML export can also be enabled by setting the environment variable
+    `PSP_JUPYTER_HTML_EXPORT` to the string `1`.
+    """
+    os.environ["PSP_JUPYTER_HTML_EXPORT"] = "1" if val else "0"

perspective.data/data/share/jupyter/labextensions/@finos/perspective-jupyterlab/install.json

@@ -0,0 +1,5 @@
+{
+    "packageManager": "python",
+    "packageName": "perspective-python",
+    "uninstallInstructions": "Use your Python package manager (pip, conda, etc.) to uninstall the package perspective-python"
+}

perspective.data/data/share/jupyter/labextensions/@finos/perspective-jupyterlab/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@finos/perspective-jupyterlab",
+  "version": "3.0.0-rc.1",
+  "description": "A Jupyterlab extension for the Perspective library, designed to be used with perspective-python.",
+  "files": [
+    "dist/**/*",
+    "src/**/*"
+  ],
+  "type": "commonjs",
+  "main": "dist/esm/perspective-jupyterlab.js",
+  "style": "dist/css/perspective-jupyterlab.css",
+  "directories": {
+    "dist": "dist/"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "bench": "npm-run-all bench:build bench:run",
+    "bench:build": "echo \"No Benchmarks\"",
+    "bench:run": "echo \"No Benchmarks\"",
+    "build": "npm-run-all build:js build:labextension",
+    "build:js": "node build.mjs",
+    "build:labextension": "jupyter labextension build .",
+    "clean": "npm-run-all clean:*",
+    "clean:dist": "rimraf dist",
+    "clean:lib": "rimraf lib",
+    "clean:labextension": "rimraf ../../rust/perspective-python/perspective/labextension",
+    "clean:nbextension": "rimraf ../../rust/perspective-python/perspective/nbextension/static",
+    "test:build": "node build.mjs --test",
+    "test:jupyter:build": "cpy \"test/arrow/*\" dist/esm",
+    "test:jupyter": "__JUPYTERLAB_PORT__=6538 npx playwright test --config ../../tools/perspective-test/playwright.config.ts -- --jupyter",
+    "test": "npm-run-all test:build",
+    "version": "yarn build"
+  },
+  "dependencies": {
+    "@finos/perspective": "workspace:^",
+    "@finos/perspective-viewer": "workspace:^",
+    "@finos/perspective-viewer-d3fc": "workspace:^",
+    "@finos/perspective-viewer-datagrid": "workspace:^",
+    "@finos/perspective-viewer-openlayers": "workspace:^",
+    "@jupyter-widgets/base": ">2 <5",
+    "@jupyterlab/application": ">2 <5",
+    "@lumino/application": "<3",
+    "@lumino/widgets": "<3"
+  },
+  "devDependencies": {
+    "@finos/perspective-esbuild-plugin": "workspace:^",
+    "@finos/perspective-test": "workspace:^",
+    "@jupyterlab/builder": "^4",
+    "@prospective.co/procss": "^0.1.15",
+    "cpy": "^9.0.1"
+  },
+  "jupyterlab": {
+    "webpackConfig": "./webpack.config.js",
+    "extension": true,
+    "outputDir": "../../rust/perspective-python/perspective.data/data/share/jupyter/labextensions/@finos/perspective-jupyterlab",
+    "sharedPackages": {
+      "@jupyter-widgets/base": {
+        "bundled": false,
+        "singleton": true
+      }
+    },
+    "discovery": {
+      "server": {
+        "base": {
+          "name": "perspective-python"
+        },
+        "managers": [
+          "pip"
+        ]
+      }
+    },
+    "_build": {
+      "load": "static\\remoteEntry.7044010cbbf2a7208035.js",
+      "extension": "./extension",
+      "style": "./style"
+    }
+  }
+}