High-end Data Visualization for the Python Ecosystem
Project description
High-end data visualization for the Python ecosystem
The Highcharts for Python Toolkit is a Python library that provides a Python wrapper for the fantastic Highcharts JS suite of JavaScript data visualization libraries, with full integration into the robust Python ecosystem.
The toolkit is composed of several different libraries, each of which provides comprehensive support for a component of the Highcharts JS suite:
Python Library |
JavaScript Library |
Description |
---|---|---|
Highcharts Core for Python |
(this library) the core Highcharts data visualization library |
|
the robust time series visualization extension to Highcharts Core |
||
the rich map visualization extension to Highcharts Core |
||
the Gantt charting extension to Highcharts Core |
||
(all libraries in the Python toolkit) |
The Highcharts Export Server |
enabling the programmatic creation of static (downloadable) data visualizations |
In order to integrate Highcharts for Python into the Python ecosystem, the library features native integration with:
Jupyter Labs/Notebook. You can now produce high-end and interactive plots and renders using the full suite of Highcharts visualization capabilities.
Pandas. Automatically produce data visualizations from your Pandas dataframes
PySpark. Automatically produce data visualizations from data in a PySpark dataframe.
…and even more use-case specific integrations in each tool in the toolkit.
COMPLETE DOCUMENTATION: https://core-docs.highchartspython.com/en/latest/index.html
Installation
To install Highcharts Core for Python, just execute:
$ pip install highcharts-core
Why Highcharts for Python?
Odds are you are aware of Highcharts JS. If not, why not? It is the world’s most popular, most powerful, category-defining JavaScript data visualization library. If you are building a web or mobile app/dashboard that will be visualizing data in some fashion, you should absolutely take a look at the Highcharts suite of solutions. Just take a look at some of their fantastic demo visualizations.
Highcharts JS is a JavaScript library. It is written in JavaScript, and is specifically used to configure and render data visualizations in a web browser (or other JavaScript-executing) environment. As a JavaScript library, its audience is JavaScript developers. But what about the broader ecosystem of Python developers and data scientists?
Python is increasingly used as the technology of choice for data science and for the backends of leading enterprise-grade applications. In other words, Python is often the backend that delivers data and content to the front-end…which then renders it using JavaScript and HTML.
There are numerous Python frameworks (Django, Flask, Tornado, etc.) with specific capabilities to simplify integration with Javascript frontend frameworks (React, Angular, VueJS, etc.). But facilitating that with Highcharts has historically been very difficult. Part of this difficulty is because the Highcharts JavaScript suite - while supporting JSON as a serialization/deserialization format - leverages JavaScript object literals to expose the full power and interactivity of its data visualizations. And while it’s easy to serialize JSON from Python, serializing and deserializing to/from JavaScript object literal notation is much more complicated. This means that Python developers looking to integrate with Highcharts typically had to either invest a lot of effort, or were only able to leverage a small portion of Highcharts’ rich functionality.
So I wrote the Highcharts for Python toolkit to bridge that gap.
Highcharts for Python provides Python object representation for all of the JavaScript objects defined in the Highcharts JS API. It provides automatic data validation, and exposes simple and standardized methods for serializing those Python objects back-and-forth to JavaScript object literal notation.
Key Highcharts for Python Features
Clean and consistent API. No reliance on “hacky” code, dict and JSON serialization, or impossible to maintain / copy-pasted “spaghetti code”.
Comprehensive Highcharts Support. Every single Highcharts chart type and every single configuration option is supported in the Highcharts for Python toolkit. This includes the over 70 data visualization types supported by Highcharts JS and the 50+ technical indicator visualizations available in Highcharts Stock, with full support for the rich JavaScript formatter (JS callback functions) capabilities that are often needed to get the most out of Highcharts’ visualization and interaction capabilities.
Simple JavaScript Code Generation. With one method call, produce production-ready JavaScript code to render your interactive visualizations using Highcharts’ rich capabilities.
Easy and Robust Chart Download. With one method call, produce high-end static visualizations that can be downloaded or shared as files with your audience. Produce static charts using the Highsoft-provided Highcharts Export Server, or using your own private export server as needed.
Integration with Pandas and PySpark. With two lines of code, produce a high-end interactive visualization of your Pandas or PySpark dataframe.
Consistent code style. For Python developers, switching between Pythonic code conventions and JavaScript code conventions can be…annoying. So Highcharts for Python applies Pythonic syntax with automatic conversion between Pythonic snake_case notation and JavaScript camelCase styles.
Highcharts for Python vs Alternatives
For a discussion of Highcharts for Python in comparison to alternatives, please see the COMPLETE DOCUMENTATION: https://core-docs.highchartspython.com/en/latest/index.html
Hello World, and Basic Usage
1. Import Highcharts Core for Python
# PRECISE-LOCATION PATTERN: BEST PRACTICE!
# This method of importing Highcharts for Python objects yields the fastest
# performance for the import statement. However, it is more verbose and requires
# you to navigate the extensive Highcharts Core for Python API.
# Import classes using precise module indications. For example:
from highcharts_core.chart import Chart
from highcharts_core.global_options.shared_options import SharedOptions
from highcharts_core.options import HighchartsOptions
from highcharts_core.options.plot_options.bar import BarOptions
from highcharts_core.options.series.bar import BarSeries
# CATCH-ALL PATTERN
# This method of importing Highcharts for Python classes has relatively slow
# performance because it imports hundreds of different classes from across the entire
# library. This performance impact may be acceptable to you in your use-case, but
# do use at your own risk.
# Import objects from the catch-all ".highcharts" module.
from highcharts_core import highcharts
# You can now access specific classes without individual import statements.
highcharts.Chart
highcharts.SharedOptions
highcharts.HighchartsOptions
highcharts.BarOptions
highcharts.BarSeries
2. Create Your Chart
# from a JavaScript file my_chart = highcharts.Chart.from_js_literal('my_js_literal.js') # from a JSON file my_chart = highcharts.Chart.from_json('my_json.json') # from a Python dict my_chart = highcharts.Chart.from_dict(my_dict_obj) # from a Pandas dataframe my_chart = highcharts.Chart.from_pandas(df, property_map = { 'x': 'transactionDate', 'y': 'invoiceAmt', 'id': 'id' }, series_type = 'line') # from a PySpark dataframe my_chart = highcharts.Chart.from_pyspark(df, property_map = { 'x': 'transactionDate', 'y': 'invoiceAmt', 'id': 'id' }, series_type = 'line') # from a CSV my_chart = highcharts.Chart.from_csv('/some_file_location/filename.csv' column_property_map = { 'x': 0, 'y': 4, 'id': 14 }, series_type = 'line') # from a HighchartsOptions configuration object my_chart = highcharts.Chart.from_options(my_options) # from a Series configuration my_chart = highcharts.Chart.from_series(my_series)
3. Configure Global Settings (optional)
# Import SharedOptions from highcharts_core.global_options.shared_options import SharedOptions # from a JavaScript file my_global_settings = SharedOptions.from_js_literal('my_js_literal.js') # from a JSON file my_global_settings = SharedOptions.from_json('my_json.json') # from a Python dict my_global_settings = SharedOptions.from_dict(my_dict_obj) # from a HighchartsOptions configuration object my_global_settings = SharedOptions.from_options(my_options)
4. Configure Your Chart / Global Settings
from highcharts_core.options.title import Title from highcharts_core.options.credits import Credits # Using dicts my_chart.title = { 'align': 'center' 'floating': True, 'text': 'The Title for My Chart', 'use_html': False, } my_chart.credits = { 'enabled': True, 'href': 'https://www.highcharts.com/', 'position': { 'align': 'center', 'vertical_align': 'bottom', 'x': 123, 'y': 456 }, 'style': { 'color': '#cccccc', 'cursor': 'pointer', 'font_size': '9px' }, 'text': 'Chris Modzelewski' } # Using direct objects from highcharts_core.options.title import Title from highcharts_core.options.credits import Credits my_title = Title(text = 'The Title for My Chart', floating = True, align = 'center') my_chart.options.title = my_title my_credits = Credits(text = 'Chris Modzelewski', enabled = True, href = 'https://www.highcharts.com') my_chart.options.credits = my_credits
5. Generate the JavaScript Code for Your Chart
Now having configured your chart in full, you can easily generate the JavaScript code that will render the chart wherever it is you want it to go:
# as a string js_as_str = my_chart.to_js_literal() # to a file (and as a string) js_as_str = my_chart.to_js_literal(filename = 'my_target_file.js')
6. Generate the JavaScript Code for Your Global Settings (optional)
# as a string global_settings_js = my_global_settings.to_js_literal() # to a file (and as a string) global_settings_js = my_global_settings.to_js_literal('my_target_file.js')
7. Generate a Static Version of Your Chart
# as in-memory bytes my_image_bytes = my_chart.download_chart(format = 'png') # to an image file (and as in-memory bytes) my_image_bytes = my_chart.download_chart(filename = 'my_target_file.png', format = 'png')
Getting Help/Support
The Highcharts for Python toolkit comes with all of the great support that you are used to from working with the Highcharts JavaScript libraries. When you license the toolkit, you are welcome to use any of the following tools to get help using the toolkit. In particular, you can:
Use the Highcharts Forums
Use Stack Overflow with the highcharts-for-python tag
Report bugs or request features in the library’s Github repository
File a support ticket with us
FOR MORE INFORMATION: https://www.highchartspython.com/get-help
Contributing
We welcome contributions and pull requests! For more information, please see the Contributor Guide. And thanks to all those who’ve already contributed!
Testing
We use TravisCI for our build automation and ReadTheDocs for our documentation.
Detailed information about our test suite and how to run tests locally can be found in our Testing Reference.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for highcharts_core-1.0.0rc2-py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | ba399965ad59364ea97dcbd6533144cb21d9951c597fc67026d255317e2e88d3 |
|
MD5 | f075a40038a122555966a5d03be5d59d |
|
BLAKE2b-256 | 7b30d5ac4b9e49940960ba2cd616afd37ee816f1a7086df158b8618a46abe155 |