perspective-python 5.6.0__cp311-abi3-pyemscripten_2026_0_wasm32.whl

perspective/widget/viewer/__init__.py

@@ -0,0 +1,15 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 .viewer import PerspectiveViewer
+
+__all__ = ["PerspectiveViewer"]

perspective/widget/viewer/viewer.py

@@ -0,0 +1,355 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 random import random
+from .viewer_traitlets import PerspectiveTraitlets
+import perspective
+
+# from .. import Server
+
+# ─  │  ┌ ┬ ┐
+# ┄  ┆  ├ ┼ ┤ ╲ ╱
+# ┈  ┊  └ ┴ ┘
+# ━  ┃  ┏ ┳ ┓ ┏ ┯ ┓ ┏ ┳ ┓ ┏ ┯ ┓
+# ┅  ┇  ┣ ╋ ┫ ┣ ┿ ┫ ┠ ╂ ┨ ┠ ┼ ┨
+# ┉  ┋  ┗ ┻ ┛ ┗ ┷ ┛ ┗ ┻ ┛ ┗ ┷ ┛
+
+# global_server = PySyncServer()
+
+
+class PerspectiveViewer(PerspectiveTraitlets, object):
+    """PerspectiveViewer wraps the `perspective.Table` API and exposes an API
+    around creating views, loading data, and updating data.
+    """
+
+    # Viewer attributes that should be saved in `save()` and restored using
+    # `restore()`. Symmetric to `PERSISTENT_ATTRIBUTES` in `perspective-viewer`.
+    PERSISTENT_ATTRIBUTES = (
+        "group_by",
+        "split_by",
+        "filter",
+        "sort",
+        "aggregates",
+        "columns",
+        "expressions",
+        "plugin",
+        "plugin_config",
+        "theme",
+        "settings",
+        "title",
+        "version",
+    )
+
+    def __init__(
+        self,
+        plugin="Datagrid",
+        columns=None,
+        columns_config=None,
+        group_by=None,
+        split_by=None,
+        group_rollup_mode=None,
+        split_rollup_mode=None,
+        aggregates=None,
+        sort=None,
+        filter=None,
+        expressions=None,
+        plugin_config=None,
+        settings=True,
+        theme=None,
+        title=None,
+        # ignored, here for restore compatibility
+        version=None,
+    ):
+        """Initialize an instance of `PerspectiveViewer` with the given viewer
+        configuration.  Do not pass a `Table` or data into the constructor -
+        use the :func:`load()` method to provide the viewer with data.
+
+        Keyword Arguments:
+            columns (:obj:`list` of :obj:`str`): A list of column names to be
+                visible to the user.
+            columns_config (:obj:`dict`): Per-column configuration (styling,
+                formatting, etc.), keyed by column name.
+            group_by (:obj:`list` of :obj:`str`): A list of column names to
+                use as group by.
+            split_by (:obj:`list` of :obj:`str`): A list of column names
+                to use as split by.
+            group_rollup_mode (:obj:`str`): How group-by rollups render; one
+                of ``rollup``, ``flat``, or ``total``.
+            split_rollup_mode (:obj:`str`): Whether split-by emits subtotal
+                and grand-total column groups; one of ``flat`` or ``rollup``.
+            aggregates (:obj:`dict` of :obj:`str` to :obj:`str`):  A dictionary
+                of column names to aggregate types, which specify aggregates
+                for individual columns.
+            sort (:obj:`list` of :obj:`list` of :obj:`str`): A list of lists,
+                each list containing a column name and a sort direction
+                (``asc``, ``desc``, ``asc abs``, ``desc abs``, ``col asc``,
+                ``col desc``, ``col asc abs``, ``col desc abs``).
+            filter (:obj:`list` of :obj:`list` of :obj:`str`): A list of lists,
+                each list containing a column name, a filter comparator, and a
+                value to filter by.
+            expressions (:obj:`list` of :obj:`str`): A list of string
+                expressions which are applied to the view.
+            plugin (:obj:`str`/:obj:`perspective.Plugin`): Which plugin to
+                select by default.
+            plugin_config (:obj:`dict`): A configuration for the plugin, i.e.
+                the datagrid plugin or a chart plugin.
+            settings(:obj:`bool`): Whether the perspective query settings
+                panel should be open.
+            theme (:obj:`str`): The color theme to use.
+            version (:obj:`str`): The version this configuration is restored from.
+                This should only be used when restoring a configuration,
+                and should not be set manually.
+
+        Examples:
+            >>> viewer = PerspectiveViewer(
+            ...     aggregates={"a": "avg"},
+            ...     group_by=["a"],
+            ...     sort=[["b", "desc"]],
+            ...     filter=[["a", ">", 1]],
+            ...     expressions=["\"a\" + 100"]
+            ... )
+        """
+
+        # The Table under management by this viewer and its
+        # attached PerspectiveManager
+        self._table = None
+        self._client = None
+
+        # Viewer configuration
+        self.plugin = plugin  # validate_plugin(plugin)
+        self.columns = columns or []  # validate_columns(columns) or []
+        self.columns_config = columns_config or {}
+        self.group_by = group_by or []  # validate_group_by(group_by) or []
+        self.split_by = split_by or []  # validate_split_by(split_by) or []
+        self.group_rollup_mode = group_rollup_mode or "rollup"
+        self.split_rollup_mode = split_rollup_mode or "flat"
+        self.aggregates = aggregates or {}  # validate_aggregates(aggregates) or {}
+        self.sort = sort or []  # validate_sort(sort) or []
+        self.filter = filter or []  # validate_filter(filter) or []
+        self.expressions = expressions or {}  # validate_expressions(expressions) or {}
+        self.plugin_config = (
+            plugin_config or {}
+        )  # validate_plugin_config(plugin_config) or {}
+        self.settings = settings
+        self.theme = theme
+        self.title = title
+
+    def new_proxy_session(self, cb):
+        return perspective.ProxySession(self._client, cb)
+
+    @property
+    def client(self):
+        """Returns the ``perspective.Client`` or ``perspective.AsyncClient`` under management by the viewer."""
+        return self._client
+
+    @property
+    def table(self):
+        """Returns the ``perspective.Table`` or ``perspective.AsyncTable`` under management by the viewer."""
+        return self._table
+
+    def is_async(self):
+        """Returns whether this widget has an async interface or synchronous"""
+        return isinstance(self._table, perspective.perspective.AsyncTable)
+
+    def load(self, data, **options):
+        """Given a ``perspective.Table``, a ``perspective.AsyncTable``,
+        or data that can be handled by ``perspective.Table``, pass it to the
+        viewer.  Like `__init__`, load accepts a `perspective.Table`, a dataset,
+        or a schema.
+
+        ``load()`` resets the state of the viewer: if a ``perspective.Table``
+        has already been  loaded, ``**options`` is ignored as the options
+        already set on the ``Table`` take precedence.
+
+        If data is passed in, a ``perspective.Table`` is automatically created
+        by this method, and the options passed to ``**config`` are extended to
+        the new Table.  If the widget already has a dataset, and the new data
+        has different columns to the old one, then the widget state (pivots,
+        sort, etc.) is cleared to prevent applying settings on columns that
+        don't exist.
+
+        When a ``perspective.AsyncTable`` is loaded, the widget's interface
+        becomes async. Methods which operate on the underlying Perspective
+        view, inclusive of the ``load()`` call itself, return coroutine values
+        which must be awaited.
+
+        Loading a ``perspective.Table`` or plain data will make the interface
+        synchronous again.
+
+        Args:
+            data (:obj:`Table`|:obj:`AsyncTable`|:obj:`dict`|:obj:`list`|:obj:`pandas.DataFrame`|:obj:`bytes`|:obj:`str`): a
+                `perspective.Table` instance, a `perspective.AsyncTable`
+                instance, or a dataset to be loaded in the viewer.
+
+        Keyword Arguments:
+            name (:obj:`str`): An optional name to reference the table by so it can
+                be accessed from the front-end. If not provided, a name will
+                be generated.
+            index (:obj:`str`): A column name to be used as the primary key.
+                Ignored if a ``Table`` or ``AsyncTable`` is supplied.
+            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 a
+                ``Table`` or ``AsyncTable`` is supplied.
+
+        Returns:
+            coro (:obj:`coroutine`): when `AsyncTable` is passed, the `load()` call must be awaited
+        """
+        name = options.pop("name", str(random()))
+
+        # Reset the viewer when `load()` is called multiple times.
+        if self.table is not None:
+            self.reset()
+
+        if isinstance(data, perspective.perspective.AsyncTable):
+            self._table = data
+            async def load_table():
+                self._client = await self.table.get_client()
+                self.table_name = self.table.get_name()
+                # If the user does not set columns to show, synchronize viewer state
+                # with dataset.
+                if len(self.columns) == 0:
+                    self.columns = await self.table.columns()
+
+            return load_table()
+        elif isinstance(data, perspective.perspective.Table):
+            self._table = data
+            self._client = data.get_client()
+        elif isinstance(data, perspective.perspective.View) or isinstance(data, perspective.perspective.AsyncView):
+            raise TypeError(
+                "Views cannot be loaded directly, load a table or raw data instead"
+            )
+        else:
+            self._table = perspective.table(data, name=name, **options)
+            self._client = perspective.GLOBAL_CLIENT
+
+        # If the user does not set columns to show, synchronize viewer state
+        # with dataset.
+        if len(self.columns) == 0:
+            self.columns = self.table.columns()
+
+        self.table_name = self.table.get_name()
+
+    def update(self, data):
+        """Update the table under management by the viewer with new data.
+        This function follows the semantics of `Table.update()`, and will be
+        affected by whether an index is set on the underlying table.
+
+        When this widget has loaded an ``AsyncTable``, returns a coroutine
+        which must be awaited.
+
+        Args:
+            data (:obj:`dict`|:obj:`list`|:obj:`pandas.DataFrame`): the
+            update data for the table.
+
+        Returns:
+            coro (:obj:`coroutine`): when async, must be awaited
+        """
+        return self.table.update(data)
+
+    def clear(self):
+        """Clears the rows of this viewer's ``Table``."""
+        if self.table is not None:
+            return self.table.clear()
+
+    def replace(self, data):
+        """Replaces the rows of this viewer's `Table` with new data.
+
+        Args:
+            data (:obj:`dict`|:obj:`list`|:obj:`pandas.DataFrame`): new data
+            to set into the table - must conform to the table's schema.
+
+        Returns:
+            coro (:obj:`coroutine`): when async, must be awaited
+        """
+        if self.table is not None:
+            return self.table.replace(data)
+
+    def save(self):
+        """Get the viewer's attributes as a dictionary, symmetric with `restore`
+        so that a viewer's configuration can be reproduced."""
+        return {
+            attr: getattr(self, attr)
+            for attr in PerspectiveViewer.PERSISTENT_ATTRIBUTES
+        }
+
+    def restore(self, **kwargs):
+        """Restore a given set of attributes, passed as kwargs
+        (e.g. dictionary). Symmetric with `save` so that a given viewer's
+        configuration can be reproduced."""
+        for k, v in kwargs.items():
+            if k in PerspectiveViewer.PERSISTENT_ATTRIBUTES:
+                setattr(self, k, v)
+
+    def to_kwargs(self):
+        """Get the viewer's attributes as a list of kwargs, which can be passed to
+        the viewer constructor"""
+        attrs = self.save()
+        defaults = {
+            "columns": [],
+            "group_by": [],
+            "split_by": [],
+            "aggregates": {},
+            "sort": [],
+            "filter": [],
+            "expressions": {},
+            "plugin_config": {},
+            "version": "2.10.0",
+        }
+        kwargs = {}
+        for key, default in defaults.items():
+            if attrs.get(key) != default:
+                kwargs[key] = attrs[key]
+        return ", ".join(
+            ["{}={}".format(attr, repr(val)) for attr, val in kwargs.items()]
+        )
+
+    def reset(self):
+        """Resets the viewer's attributes and state, but does not delete or
+        modify the underlying `Table`.
+
+        Example:
+            widget = PerspectiveWidget(data, group_by=["date"], plugin=Plugin.XBAR)
+            widget.reset()
+            widget.plugin  #
+        """
+        self.group_by = []
+        self.split_by = []
+        self.filter = []
+        self.sort = []
+        self.expressions = {}
+        self.aggregates = {}
+        self.columns = []
+        self.plugin = "Datagrid"
+        self.plugin_config = {}
+
+    def delete(self, delete_table=True):
+        """Delete the Viewer's data and clears its internal state. If
+        ``delete_table`` is True, the underlying `perspective.Table` and the
+        internal `View` object will be deleted.
+
+        Args:
+            delete_table (:obj:`bool`) : whether the underlying `Table` will be
+                deleted. Defaults to True.
+
+        Returns:
+            coro (:obj:`coroutine`): when async and `delete_table` is `True`,
+                must be awaited
+        """
+        ret = None
+        if delete_table:
+            # Delete table
+            ret = self.table.delete()
+            self.table_name = None
+            self._table = None
+
+        self.reset()
+        return ret

perspective/widget/viewer/viewer_traitlets.py

@@ -0,0 +1,98 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 traitlets import HasTraits, Unicode, List, Bool, Dict, Enum
+
+import importlib.metadata
+
+__version__ = importlib.metadata.version("perspective-python")
+
+
+class PerspectiveTraitlets(HasTraits):
+    """Define the traitlet interface with `PerspectiveJupyterWidget` on the
+    front end. Attributes which are set here are synchronized between the
+    front-end and back-end.
+
+    Examples:
+        >>> widget = perspective.PerspectiveWidget(
+        ...     data, group_by=["a", "b", "c"])
+        PerspectiveWidget(group_by=["a", "b", "c"])
+        >>> widget.split_by=["b"]
+        >>> widget
+        PerspectiveWidget(group_by=["a", "b", "c"], split_by=["b"])
+    """
+
+    # `perspective-viewer` options
+    plugin = Unicode("Datagrid").tag(sync=True)
+    columns = List(default_value=[]).tag(sync=True)
+    columns_config = Dict(default_value={}).tag(sync=True)
+    group_by = List(trait=Unicode(), default_value=[]).tag(sync=True, o=True)
+    split_by = List(trait=Unicode(), default_value=[]).tag(sync=True)
+    group_rollup_mode = Enum(("rollup", "flat", "total"), default_value="rollup").tag(
+        sync=True
+    )
+    split_rollup_mode = Enum(("flat", "rollup"), default_value="flat").tag(sync=True)
+    aggregates = Dict(default_value={}).tag(sync=True)
+    sort = List(default_value=[]).tag(sync=True)
+    filter = List(default_value=[]).tag(sync=True)
+    expressions = Dict(default_value=[]).tag(sync=True)
+    plugin_config = Dict(default_value={}).tag(sync=True)
+    settings = Bool(True).tag(sync=True)
+    theme = Unicode("Pro Light", allow_none=True).tag(sync=True)
+
+    # used to tell the frontend which table to connect to
+    table_name = Unicode(None, allow_none=True).tag(sync=True)
+
+    server = Bool(False).tag(sync=True)
+    binding_mode = Enum(("server", "client-server")).tag(default="server", sync=True)
+    title = Unicode(None, allow_none=True).tag(sync=True)
+    version = Unicode(__version__).tag(sync=True)
+
+    # @validate("plugin")
+    # def _validate_plugin(self, proposal):
+    #     return validate_plugin(proposal.value)
+
+    # @validate("columns")
+    # def _validate_columns(self, proposal):
+    #     return validate_columns(proposal.value)
+
+    # @validate("group_by")
+    # def _validate_group_by(self, proposal):
+    #     return validate_group_by(proposal.value)
+
+    # @validate("split_by")
+    # def _validate_split_by(self, proposal):
+    #     return validate_split_by(proposal.value)
+
+    # @validate("aggregates")
+    # def _validate_aggregates(self, proposal):
+    #     return validate_aggregates(proposal.value)
+
+    # @validate("sort")
+    # def _validate_sort(self, proposal):
+    #     return validate_sort(proposal.value)
+
+    # @validate("filter")
+    # def _validate_filter(self, proposal):
+    #     return validate_filter(proposal.value)
+
+    # @validate("expressions")
+    # def _validate_expressions(self, proposal):
+    #     return validate_expressions(proposal.value)
+
+    # @validate("plugin_config")
+    # def _validate_plugin_config(self, proposal):
+    #     return validate_plugin_config(proposal.value)
+
+    # @validate("title")
+    # def _validate_title(self, proposal):
+    #     return validate_title(proposal.value)

perspective_python-5.6.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: perspective-python
+Version: 5.6.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Jupyter :: JupyterLab
+Classifier: Framework :: Jupyter :: JupyterLab :: 3
+Classifier: Framework :: Jupyter :: JupyterLab :: Extensions
+Classifier: Framework :: Jupyter :: JupyterLab :: Extensions :: Prebuilt
+Requires-Dist: aiohttp>=2,<4 ; extra == 'aiohttp'
+Requires-Dist: anywidget>=0.9 ; extra == 'jupyter'
+Requires-Dist: starlette<1 ; extra == 'starlette'
+Requires-Dist: tornado>=5,<7 ; extra == 'tornado'
+Provides-Extra: aiohttp
+Provides-Extra: jupyter
+Provides-Extra: starlette
+Provides-Extra: tornado
+License-File: LICENSE.md
+License-File: LICENSE_THIRDPARTY_cargo.yml
+Summary: Interactive data grid, pivot table and charts for large, real-time and streaming datasets, with a Jupyter widget and WebSocket server.
+Keywords: datagrid,pivot,visualization,analytics,dashboard,jupyter,anywidget,streaming,real-time,arrow,pandas,polars,duckdb,webassembly
+Home-Page: https://perspective-dev.github.io
+License-Expression: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/perspective-dev/perspective/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://perspective-dev.github.io/guide/
+Project-URL: Homepage, https://perspective-dev.github.io
+Project-URL: Issues, https://github.com/perspective-dev/perspective/issues
+Project-URL: Repository, https://github.com/perspective-dev/perspective
+
+# `perspective-python`
+
+[![PyPI](https://img.shields.io/pypi/v/perspective-python.svg?style=for-the-badge)](https://pypi.org/project/perspective-python/)
+
+Perspective is an open-source data grid, pivot table and charting component for 
+large, real-time and streaming datasets.
+
+`perspective-python` is the Python distribution of Perspective:
+
+- A streaming query engine — `Table` and `View` — with incremental pivots,
+  aggregates, filters, expressions and joins, reading and writing
+  [Apache Arrow](https://arrow.apache.org/), CSV, JSON, `pandas`, `polars` and
+  `pyarrow`. Tables can be memory-mapped from disk with `page_to_disk=True`
+  to exceed available memory.
+- `PerspectiveWidget`, an interactive data grid, pivot table and charting
+  widget for JupyterLab, Jupyter Notebook, VS Code notebooks, Google Colab and
+  marimo, built on [anywidget](https://anywidget.dev/).
+- WebSocket handlers for Tornado, Starlette (FastAPI) and aiohttp, which serve
+  real-time dashboards to `<perspective-viewer>` in the browser.
+- Virtual servers which run the same UI directly against DuckDB, ClickHouse,
+  PostgreSQL and Polars, with no data copy.
+
+## Installation
+
+```bash
+pip install perspective-python
+```
+
+For notebooks, install the `jupyter` extra:
+
+```bash
+pip install "perspective-python[jupyter]"
+```
+
+## An interactive pivot table in Jupyter
+
+```python
+import pandas as pd
+from perspective.widget import PerspectiveWidget
+
+df = pd.read_csv("superstore.csv")
+PerspectiveWidget(df, plugin="Y Bar", group_by=["Region"], columns=["Sales"])
+```
+
+## A streaming `Table`
+
+```python
+import perspective
+
+server = perspective.Server()
+client = server.new_local_client()
+table = client.table({"symbol": "string", "price": "float"}, name="prices")
+table.update([{"symbol": "AAPL", "price": 189.5}])
+```
+
+## A real-time dashboard server
+
+```python
+import tornado.ioloop
+import tornado.web
+from perspective.handlers.tornado import PerspectiveTornadoHandler
+
+app = tornado.web.Application([
+    (r"/websocket", PerspectiveTornadoHandler, {"perspective_server": server}),
+])
+
+app.listen(8888)
+tornado.ioloop.IOLoop.current().start()
+```
+
+Any number of browser clients can then open the `prices` table over WebSocket
+and receive every `update()` as it happens.
+
+## Documentation
+
+- [Project site and live examples](https://perspective-dev.github.io/)
+- [User guide](https://perspective-dev.github.io/guide/)
+- [Example gallery](https://perspective-dev.github.io/gallery/index.html)
+- [GitHub](https://github.com/perspective-dev/perspective)
+- [Python API reference](https://perspective-dev.github.io/python/index.html)
+