Summer has continued to deliver features for data scientists, developers, and analysts to the deephaven-core project. Last month’s easy Python
pip installation is followed by the first integration of Deephaven’s real-time widgets with Jupyter, the official release of the requested Go client, and many quality-of-life improvements.
The complete 0.15.0 release notes can be found on GitHub.
Real-time and interactive widgets in Jupyter
Now, you can use that same Table widget in a Jupyter Notebook.
And it displays real-time and updating data!
That's a first, right?!? We’re excited for you to use these!
So here's what you get: A rich, stateful table experience… capable of handling dynamic and real-time data... within Jupyter... with just a few lines of code:
#install and start the deephaven-core server
pip install deephaven-server
#install and use the iPython widget plugin
pip install deephaven-ipywidgets
from deephaven_server import Server
s = Server(port=8080)
The README from the deephaven-ipywidgets GitHub project provides further instructions and context for this feature. We look forward to your feedback.
We know you want real-time plots in Jupyter, too. Those will be available to Jupyter users by the end of August.
A Golang client API
Yep. It’s a Go.
You can now receive snapshots from the Deephaven server in a Go client and push static or streaming data from the client to the server.
Below is a ‘hello world’ version of a client application, generating a simple (real-time) ticking table of timestamps.
ctx := context.Background()
myClient, err := client.NewClient(ctx, "localhost", "10000", client.WithConsole("python"))
timeTable, err := myClient.TimeTable(ctx, time.Second, time.Now())
err = myClient.BindToVariable(ctx, "myTimeTable", timeTable)
Improvements to the
In the last release, we introduced a new table method,
updateBy(), to support common operations like cum-sums, -maxes, -mins, -products, and time- and count-based EMAs. In this release, we’ve now wrapped it for Python users (i.e.
update_by()), addressed usability, and improved performance by using open address hashing under the covers. The Pydocs and Javadocs will soon be augmented with other documentation.
More Python Table API improvements
As noted above, since we were wrapping an aggregation, we double-backed on some earlier work. We added weighted-average, weighted-sum, and absolute-sum to join the list of other expected keyed aggregations in the Python Table API.
In the last several releases, we’ve added features related to creating subtables based on keys. Supporting such a structure with real-time data will give you superpowers for speed and parallelization for workloads with natural stripes. In this release, we have improved the ease-of-use of partition_by() via the Python Table API.
Real-time plotting API now supports Treemap charts
Deephaven has a low-level integration with plotly, enabling you to inherit various real-time charts and graphs. This release adds plotly’s treemap charts to the arsenal. You can find guidance on how to use this feature – for both static and updating data sources – in the docs. And again, these Tablemaps update in real-time as new data arrives, as you'd expect with Deephaven.
Developers are focusing current efforts on:
- Final testing of a feature to receive updating data via our C++ client API.
- Architectural work to ensure Deephaven as a library is easy to use regardless of your operating system.
- Further window-related use cases to extend
- Authentication and authorization hooks.
- Direct support for Python plotly chart rendering in the web IDE experience (for snapshot data without the need for the Deephaven plotting API).
- Ease-of-use for deploying iframe-embedded widgets.
- Research related to data persistence and cloud deployment.
Check out those Jupyter widgets!