################################################### Highcharts Gantt for Python ###################################################
High-end Gantt chart visualization for the Python ecosystem
Highcharts Gantt for Python is an extension to the
Highcharts Stock for Python <https://stock-docs.highchartspython.com>__ library, providing
a Python wrapper for the
Highcharts Gantt <https://www.highcharts.com/products/gantt/>__
JavaScript data visualization library.
Highcharts Gantt for Python also supports
The library supports Highcharts (JS) v.10.2 and higher, including Highcharts (JS) v.11.4.0.
Highcharts Gantt for Python is fully integrated with the broader Python ecosystem, featuring native integrations with:
COMPLETE DOCUMENTATION: http://gantt-docs.highchartspython.com/en/latest/index.html
The Highcharts for Python Toolkit
The Highcharts Gantt for Python library is part of the broader
Highcharts for Python Toolkit <https://www.highcharts.com/integrations/python>,
which together provides comprehensive support across the entire
Highcharts <https://www.highcharts.com> suite of data visualization libraries:
.. list-table:: :widths: 30 30 40 :header-rows: 1
Highcharts Core for Python <https://core-docs.highchartspython.com/>__Highcharts Core (JS) <https://www.highcharts.com/products/highcharts/>__Highcharts Stock for Python <https://stock-docs.highchartspython.com/>__Highcharts Stock (JS) <https://www.highcharts.com/products/stock/>__Highcharts Maps for Python <https://maps-docs.highchartspython.com/>__Highcharts Maps (JS) <https://www.highcharts.com/products/maps/>__Highcharts Gantt (JS) <https://www.highcharts.com/products/gantt/>__Installation
To install Highcharts Gantt for Python, just execute:
.. code-block:: bash
$ pip install highcharts-gantt
Before you install, please be aware of the following "hard" dependencies:
Highcharts Stock for Python <https://stock-docs.highchartspython.com/en/latest/>__ v.1.7 or higheresprima-python <https://github.com/Kronuz/esprima-python>__ v.4.0 or higherrequests <https://requests.readthedocs.io/en/latest/>__ v.2.31 or highervalidator-collection <https://validator-collection.readthedocs.io/en/latest/>__
v.1.5 or higherYou can find more information about soft and development dependencies in the
complete documentation <https://gantt-docs.highchartspython.com/en/latest/#dependencies>__.
Why Highcharts for Python?
Highcharts <https://www.highcharts.com>__ 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. Take a peak at some
fantastic demo visualizations <https://www.highcharts.com/demo>__.
As a suite of JavaScript libraries, Highcharts <https://www.highcharts.com>__ is
written in JavaScript, and is used to configure and render data visualizations in a
web browser (or other JavaScript-executing) environment. As a set of JavaScript
libraries, its audience is JavaScript developers. But what about the broader ecosystem of
Python developers and data scientists?
Given Python's increasing adoption as the technology of choice for data science and for the backends of leading enterprise-grade applications, 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 we 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 (JavaScript) API <https://api.highcharts.com/highcharts/>__. It provides automatic
data validation, and exposes simple and standardized methods for serializing those Python
objects back-and-forth to JavaScript object literal notation.
Highcharts Gantt for Python provides support for
the Highcharts Gantt <https://www.highcharts.com/products/maps/>__ extension, which is
designed to provide extensive capabilities optimized for project, time, and resource
allocation data visualization with robust interactivity. For ease of use, it also includes
the full functionality of
Highcharts Stock for Python <https://stock-docs.highchartspython.com/>__ and
Highcharts Core for Python <https://core-docs.highchartspython.com/>__.
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 Highcharts Gantt for Python. This includes:
Highcharts Core <https://www.highcharts.com/product/highcharts/>__,Highcharts Stock <https://www.highcharts.com/products/stock/>__Highcharts Gantt <https://www.highcharts.com/product/gantt/>__all 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.
.. note::
See Also:
Supported Visualizations <https://gantt-docs.highchartspython.com/en/latest/visualizations.html>__Simple JavaScript Code Generation. With one method call, produce production-ready JavaScript code to render your interactive visualizations using Highcharts' rich capabilities.
Easy 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 Asana, Monday.com, and Jira. Your project data likely lives in
a modern project management platform like Asana <https://www.asana.com/>,
Monday.com <https://www.monday.com>, or Atlassian JIRA <https://www.atlassian.com>__.
You can easily pull data from those platforms into your Highcharts Gantt visualizations
using one method call.
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.
|
For a discussion of Highcharts Gantt for Python in comparison to alternatives, please see the COMPLETE DOCUMENTATION: http://gantt-docs.highchartspython.com/en/latest/index.html
Hello World, and Basic Usage
.. code-block:: python
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
from highcharts_core import highcharts
highcharts.Chart highcharts.SharedOptions highcharts.HighchartsOptions highcharts.BarOptions highcharts.BarSeries
.. code-block:: python
# from a primitive array, using keyword arguments
my_chart = Chart(data = [[1, 23], [2, 34], [3, 45]],
series_type = 'line')
# from a primitive array, using the .from_array() method
my_chart = Chart.from_array([[1, 23], [2, 34], [3, 45]],
series_type = 'line')
# from a Numpy ndarray, using keyword arguments
my_chart = Chart(data = numpy_array, series_type = 'line')
# from a Numpy ndarray, using the .from_array() method
my_chart = Chart.from_array(data = numpy_array, series_type = 'line')
# from a JavaScript file
my_chart = Chart.from_js_literal('my_js_literal.js')
# from a JSON file
my_chart = Chart.from_json('my_json.json')
# from a Python dict
my_chart = Chart.from_dict(my_dict_obj)
# from a Pandas dataframe
my_chart = Chart.from_pandas(df)
# from a PySpark dataframe
my_chart = Chart.from_pyspark(df,
property_map = {
'x': 'transactionDate',
'y': 'invoiceAmt',
'id': 'id'
},
series_type = 'line')
# from a CSV
my_chart = Chart.from_csv('/some_file_location/filename.csv')
# from a HighchartsOptions configuration object
my_chart = Chart.from_options(my_options)
# from a Series configuration, using keyword arguments
my_chart = Chart(series = my_series)
# from a Series configuration, using .from_series()
my_chart = Chart.from_series(my_series)
.. code-block:: python
# 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)
.. code-block:: python
from highcharts_core.options.title import Title
from highcharts_core.options.credits import Credits
# EXAMPLE 1.
# 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.highchartspython.com/',
'position': {
'align': 'center',
'vertical_align': 'bottom',
'x': 123,
'y': 456
},
'style': {
'color': '#cccccc',
'cursor': 'pointer',
'font_size': '9px'
},
'text': 'Chris Modzelewski'
}
# EXAMPLE 2.
# 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.highchartspython.com')
my_chart.options.credits = my_credits
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:
.. code-block:: python
# EXAMPLE 1.
# as a string
js_as_str = my_chart.to_js_literal()
# EXAMPLE 2.
# to a file (and as a string)
js_as_str = my_chart.to_js_literal(filename = 'my_target_file.js')
.. code-block:: python
# 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')
.. code-block:: python
# 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')
.. code-block:: python
my_chart.display()
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 channels to get help using the toolkit:
Highcharts Forums <https://highcharts.com/forum>__Stack Overflow <https://stackoverflow.com/questions/tagged/highcharts-for-python>__
with the highcharts-for-python tagReport bugs or request features <https://github.com/highcharts-for-python/highcharts-gantt/issues>__File a support ticket <https://www.highchartspython.com/get-help>__ with usSchedule a live chat or video call <https://www.highchartspython.com/get-help>__
with usFOR MORE INFORMATION: https://www.highchartspython.com/get-help
Contributing
We welcome contributions and pull requests! For more information, please see the
Contributor Guide <https://gantt-docs.highchartspython.com/en/latest/contributing.html>.
And thanks to all those who've already contributed!
Testing
We use TravisCI <http://travisci.com>_ for our build automation and
ReadTheDocs <https://readthedocs.com>_ for our documentation.
Detailed information about our test suite and how to run tests locally can be found in our Testing Reference.
FAQs
High-end Gantt Chart Visualization for the Python Ecosystem
We found that highcharts-gantt demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
In this segment of the Risky Business podcast, Feross Aboukhadijeh and Patrick Gray discuss the challenges of tracking malware discovered in open source softare.
Research
Security News
A threat actor's playbook for exploiting the npm ecosystem was exposed on the dark web, detailing how to build a blockchain-powered botnet.
Security News
NVD’s backlog surpasses 20,000 CVEs as analysis slows and NIST announces new system updates to address ongoing delays.