try:
from dotenv import load_dotenv
load_dotenv()
except ImportError:
pass
import json
import os
from typing import Optional, Dict, List
import requests
from validator_collection import validators, checkers
from highcharts_core import errors, constants
from highcharts_core.decorators import class_sensitive
from highcharts_core.metaclasses import HighchartsMeta
from highcharts_core.utility_classes.javascript_functions import CallbackFunction
from highcharts_core.options import HighchartsOptions
from highcharts_core.options.data import Data
class ExportServer(HighchartsMeta):
"""Class that provides methods for interacting with the Highcharts
`Export Server <https://github.com/highcharts/node-export-server>`_.
.. note::
By default, the :class:`ExportServer` class operates using the Highcharts-provided
export server. If you wish to use your own (or a custom) export server, you can
configure the class using either the :meth:`url <ExportServer.url>`,
:meth:`port <ExportServer.port>`, and
:meth:`path <ExportServer.path>` properties explicitly or by setting
the ``HIGHCHARTS_EXPORT_SERVER_DOMAIN`, ``HIGHCHARTS_EXPORT_SERVER_PORT``, or
``HIGHCHARTS_EXPORT_SERVER_PATH`` environment variables.
"""
def __init__(self, **kwargs):
self._url = None
self._port = None
self._path = None
self._options = None
self._format_ = None
self._scale = None
self._width = None
self._height = None
self._callback = None
self._constructor = None
self._use_base64 = None
self._no_download = None
self._async_rendering = None
self._global_options = None
self._data_options = None
self._custom_code = None
self._resources = None
self._files = None
self._css = None
self._js = None
self.protocol = kwargs.get('protocol',
os.getenv('HIGHCHARTS_EXPORT_SERVER_PROTOCOL',
'https'))
self.domain = kwargs.get('domain', os.getenv('HIGHCHARTS_EXPORT_SERVER_DOMAIN',
'export.highcharts.com'))
self.port = kwargs.get('port', os.getenv('HIGHCHARTS_EXPORT_SERVER_PORT',
''))
self.path = kwargs.get('path', os.getenv('HIGHCHARTS_EXPORT_SERVER_PATH',
''))
self.options = kwargs.get('options', None)
self.format_ = kwargs.get('format_', kwargs.get('type', 'png'))
self.scale = kwargs.get('scale', 1)
self.width = kwargs.get('width', None)
self.height = kwargs.get('height', None)
self.callback = kwargs.get('callback', None)
self.constructor = kwargs.get('constructor', 'chart')
self.use_base64 = kwargs.get('use_base64', False)
self.no_download = kwargs.get('no_download', False)
self.async_rendering = kwargs.get('async_rendering', False)
self.global_options = kwargs.get('global_options', None)
self.data_options = kwargs.get('data_options', None)
self.custom_code = kwargs.get('custom_code', None)
files = kwargs.get('files', None)
css = kwargs.get('css', None)
js = kwargs.get('js', None)
resources = kwargs.get('resources', None)
if resources:
self.resources = kwargs.get('resources', None)
else:
self.files = files
self.css = css
self.js = js
super().__init__(**kwargs)
@property
def protocol(self) -> Optional[str]:
"""The protocol over which the Highcharts for Python library should communicate
with the :term:`Export Server`. Accepts either ``'https'`` or ``'http'``. Defaults
to the ``HIGHCHARTS_EXPORT_SERVER_PROTOCOL`` environment variable if present,
otherwise falls back to default of ``'https'``.
.. tip::
This property is set automatically by the ``HIGHCHARTS_EXPORT_SERVER_PROTOCOL``
environment variable, if present.
.. warning::
If set to :obj:`None <python:None>`, will fall back to the
``HIGHCHARTS_EXPORT_SERVER_PROTOCOL`` value if available, and the Highsoft-
provided server (``'export.highcharts.com'``) if not.
:rtype: :class:`str <python:str>`
"""
return self._protocol
@protocol.setter
def protocol(self, value):
value = validators.string(value, allow_empty = True)
if not value:
value = os.getenv('HIGHCHARTS_EXPORT_SERVER_PROTOCOL', 'https')
value = value.lower()
if value not in ['https', 'http']:
raise errors.HighchartsUnsupportedProtocolError(f'protocol expects either '
f'"https" or "http". '
f'Received: "{value}"')
self._protocol = value
self._url = None
@property
def domain(self) -> Optional[str]:
"""The domain where the :term:`Export Server` can be found. Defaults to the
Highsoft-provided Export Server at ``'export.highcharts.com'``, unless over-ridden
by the ``HIGHCHARTS_EXPORT_SERVER_DOMAIN`` environment variable.
.. tip::
This property is set automatically by the ``HIGHCHARTS_EXPORT_SERVER_DOMAIN``
environment variable, if present.
.. warning::
If set to :obj:`None <python:None>`, will fall back to the
``HIGHCHARTS_EXPORT_SERVER_DOMAIN`` value if available, and the Highsoft-
provided server (``'export.highcharts.com'``) if not.
:rtype: :class:`str <pythoon:str>`
"""
return self._domain
@domain.setter
def domain(self, value):
value = validators.domain(value, allow_empty = True)
if not value:
value = os.getenv('HIGHCHARTS_EXPORT_SERVER_DOMAIN',
'export.highcharts.com')
self._domain = value
self._url = None
@property
def port(self) -> Optional[int]:
"""The port on which the :term:`Export Server` can be found. Defaults to
:obj:`None <python:None>` (for the Highsoft-provided export server), unless
over-ridden by the ``HIGHCHARTS_EXPORT_SERVER_PORT`` environment variable.
.. tip::
This property is set automatically by the ``HIGHCHARTS_EXPORT_SERVER_PORT``
environment variable, if present.
.. warning::
If set to :obj:`None <python:None>`, will fall back to the
``HIGHCHARTS_EXPORT_SERVER_PORT`` value if available. If unavailable, will
revert to :obj:`None <python:None>`.
:rtype: :class:`str <pythoon:str>`
"""
return self._port
@port.setter
def port(self, value):
if value or value == 0:
value = validators.integer(value,
allow_empty = True,
minimum = 0,
maximum = 65536)
else:
value = os.getenv('HIGHCHARTS_EXPORT_SERVER_PORT', None)
self._port = value
self._url = None
@property
def path(self) -> Optional[str]:
"""The path (at the :meth:`ExportServer.url`) where the :term:`Export Server` can
be reached. Defaults to :obj:`None <python:None>` (for the Highsoft-provided
export server), unless over-ridden by the ``HIGHCHARTS_EXPORT_SERVER_PATH``
environment variable.
.. tip::
This property is set automatically by the ``HIGHCHARTS_EXPORT_SERVER_PATH``
environment variable, if present.
.. warning::
If set to :obj:`None <python:None>`, will fall back to the
``HIGHCHARTS_EXPORT_SERVER_PATH`` value if available. If unavailable, will
revert to :obj:`None <python:None>`.
:rtype: :class:`str <pythoon:str>`
"""
return self._path
@path.setter
def path(self, value):
value = validators.path(value, allow_empty = True)
if value is None:
value = os.getenv('HIGHCHARTS_EXPORT_SERVER_PATH', None)
self._path = value
self._url = None
@property
def url(self) -> Optional[str]:
"""The fully-formed URL for the :term:`Export Server`, consisting of a
:meth:`protocol <ExportServer.protocol>`, a :meth:`domain <ExportServer.domain>`,
and optional :meth:`port <ExportServer.port>` and
:meth:`path <ExportServer.path>`.
.. note::
If explicitly set, will override the values in related properties:
* :meth:`protocol <ExportServer.protocol>`,
* :meth:`domain <ExportServer.domain>`,
* :meth:`port <ExportServer.port>`, and
* :meth:`path <ExportServer.path>`
:rtype: :class:`str <python:str>`
"""
if self._url:
return self._url
else:
return_value = f'{self.protocol}://{self.domain}'
if self.port is not None:
return_value += f':{self.port}/'
if self.path is not None:
return_value += self.path
return return_value
@url.setter
def url(self, value):
value = validators.url(
value,
allow_empty=True,
allow_special_ips=os.getenv("HCP_ALLOW_SPECIAL_IPS", False),
)
if not value:
self.protocol = None
self.domain = None
self.port = None
self.path = None
else:
original_value = value
self.protocol = value[:value.index(':')]
protocol = self.protocol + '://'
value = value.replace(protocol, '')
no_port = False
try:
end_of_domain = value.index(':')
self.domain = value[:end_of_domain]
except ValueError:
no_port = True
try:
end_of_domain = value.index('/')
self.domain = value[:end_of_domain]
except ValueError:
self.domain = value
domain = self.domain + '/'
if domain in value:
value = value.replace(domain, '')
elif self.domain in value:
value = value.replace(self.domain, '')
if value and no_port:
if value.startswith('/'):
self.path = value[1:]
else:
self.path = value
else:
if value.startswith(':'):
start_of_port = 1
else:
start_of_port = 0
try:
end_of_port = value.index('/')
except ValueError:
end_of_port = None
if end_of_port:
self.port = value[start_of_port:end_of_port]
else:
self.port = value[start_of_port:]
port = f':{self.port}'
value = value.replace(port, '')
if value.startswith('/'):
self.path = value[1:]
elif value:
self.path = value
else:
self.path = None
self._url = original_value
@property
def options(self) -> Optional[HighchartsOptions]:
"""The :class:`HighchartsOptions` which should be applied to render the exported
chart. Defaults to :obj:`None <python:None>`.
:rtype: :class:`HighchartsOptions` or :obj:`None <pythoN:None>`
"""
return self._options
@options.setter
@class_sensitive(HighchartsOptions)
def options(self, value):
self._options = value
@property
def format_(self) -> Optional[str]:
"""The format in which the exported chart should be returned. Defaults to
``'png'``.
Accepts:
* ``'png'``
* ``'jpeg'``
* ``'pdf'``
* ``'svg'``
* ``'image/svg+xml'``
:rtype: :class:`str <python:str>` or :obj:`None <python:None>`
"""
return self._format_
@format_.setter
def format_(self, value):
value = validators.string(value, allow_empty = True)
if not value:
self._format_ = None
else:
value = value.lower()
if value not in ['png', 'jpeg', 'pdf', 'svg', 'image/svg+xml']:
raise errors.HighchartsUnsupportedExportTypeError(
f'format_ expects either '
f'"png", "jpeg", "pdf", "svg", or '
f'"image/svg+xml". Received: {value}'
)
if value == 'svg':
value = 'image/svg+xml'
self._format_ = value
@property
def scale(self) -> Optional[int | float]:
"""The scale factor by which the exported chart image should be scaled. Defaults
to ``1``.
.. tip::
Use this setting to improve resolution when exporting PNG or JPEG images. For
example, setting ``.scale = 2`` on a chart whose width is 600px will produce
an image with a width of 1200px.
.. warning::
If :meth:`width <ExportServer.width>` is explicitly set, this setting will be
overridden.
:rtype: numeric
"""
return self._scale
@scale.setter
def scale(self, value):
value = validators.numeric(value,
allow_empty = True,
minimum = 0)
if not value:
value = 1
self._scale = value
@property
def width(self) -> Optional[int | float]:
"""The width that the exported chart should have. Defaults to
:obj:`None <python:None>`.
.. warning::
If explicitly set, this setting will override
:meth:`scale <ExportServer.scale>`.
:rtype: numeric or :obj:`None <python:None>`
"""
return self._width
@width.setter
def width(self, value):
value = validators.numeric(value,
allow_empty = True,
minimum = 0)
if not value:
value = None
self._width = value
@property
def height(self) -> Optional[int | float]:
"""The height that the exported chart should have. Defaults to
:obj:`None <python:None>`.
.. warning::
If explicitly set, this setting will override
:meth:`scale <ExportServer.scale>`.
:rtype: numeric or :obj:`None <python:None>`
"""
return self._height
@height.setter
def height(self, value):
value = validators.numeric(value, allow_empty=True, minimum=0)
if not value:
value = None
self._height = value
@property
def callback(self) -> Optional[CallbackFunction]:
"""A JavaScript function to execute in the (JavaScript) Highcharts constructor.
.. note::
This setting is equivalent to providing the :meth:`Chart.callback` setting.
:rtype: :class:`CallbackFunction` or :obj:`None <pythoN:None>`
"""
return self._callback
@callback.setter
@class_sensitive(CallbackFunction)
def callback(self, value):
self._callback = value
@property
def constructor(self) -> Optional[str]:
"""The (JavaScript) constructor to use when generating the exported chart.
Defaults to :obj:`None <python:None>`.
Accepts:
* ``'Chart'``
* ``'chart'``
* ``'Stock'``
* ``'stockChart'``
* ``'Map'``
* ``'mapChart'``
* ``'Gantt'``
* ``'ganttChart'``
:rtype: :class:`str <python:str>` or :obj:`None <python:None>`
"""
return self._constructor
@constructor.setter
def constructor(self, value):
value = validators.string(value, allow_empty = True)
if not value:
self._constructor = None
else:
if value not in ['Chart', 'Stock', 'Map', 'Gantt', 'chart', 'stockChart', 'mapChart', 'ganttChart',]:
raise errors.HighchartsUnsupportedConstructorError(f'constructor expects '
f'"Chart", "Stock", "Map", "Gantt", "chart", '
f'"stockChart", "mapChart", or "ganttChart", but '
f'received: "{value}"')
if value == 'Chart':
value = 'chart'
elif value == 'Stock':
value = 'stockChart'
elif value == 'Map':
value = 'mapChart'
elif value == 'Gantt':
value = 'ganttChart'
self._constructor = value
@property
def use_base64(self) -> bool:
"""If ``True``, returns the exported chart in base64 encoding. If ``False``,
returns the exported chart in binary. Defaults to ``False``.
:rtype: :class:`bool <python:bool>`
"""
return self._use_base64
@use_base64.setter
def use_base64(self, value):
self._use_base64 = bool(value)
@property
def no_download(self) -> bool:
"""If ``True``, will not send attachment headers in the HTTP response when
exporting a chart. Defaults to ``False``.
:rtype: :class:`bool <python:bool>`
"""
return self._no_download
@no_download.setter
def no_download(self, value):
self._no_download = bool(value)
@property
def async_rendering(self) -> bool:
"""If ``True``, will delay the (server-side) rendering of the exported chart
until all scripts, functions, and event handlers provided have been executed
and the (JavaScript) method ``highexp.done()`` is called. Defaults to ``False``.
:rtype: :class:`bool <python:bool>`
"""
return self._async_rendering
@async_rendering.setter
def async_rendering(self, value):
self._async_rendering = bool(value)
@property
def global_options(self) -> Optional[HighchartsOptions]:
"""The global options which will be passed to the (JavaScript)
``Highcharts.setOptions()`` method, and which will be applied to the exported
chart. Defaults to :obj:`None <python:None>`.
:rtype: :class:`HighchartsOptions`
"""
return self._global_options
@global_options.setter
@class_sensitive(HighchartsOptions)
def global_options(self, value):
self._global_options = value
@property
def data_options(self) -> Optional[Data]:
"""Configuration of data options to add data to the chart from sources like CSV.
Defaults to :obj:`None <python:None>`.
:rtype: :class:`Data` or :obj:`None <python:None>`
"""
return self._data_options
@data_options.setter
@class_sensitive(Data)
def data_options(self, value):
self._data_options = value
@property
def custom_code(self) -> Optional[CallbackFunction]:
"""When :meth:`data_options <ExportServer.data_options>` is not
:obj:`None <python:None>`, this (JavaScript) callback function is executed after
the data options are applied. The only argument it receives is the complete
set of :class:`HighchartsOptions` (as a JS literal object), which will be passed
to the Highcharts constructor on return. Defaults to :obj:`None <python:None>`.
:rtype: :class:`CallbackFunction` or :obj:`None <python:None>`
"""
return self._custom_code
@custom_code.setter
@class_sensitive(CallbackFunction)
def custom_code(self, value):
self._custom_code = value
@property
def resources(self) -> Optional[Dict]:
"""A dictionary of resources to be used in the export server.
Expects to contain up to three keys:
* ``files`` which contains an array of JS filenames
* ``js`` which contains a string representation of JS code
* ``css`` which contains a string representation of CSS code that will
applied to the chart on export
Defaults to :obj:`None <python:None>`.
:rtype: :class:`dict <python:dict>` or :obj:`None <python:None>`
"""
resources = {}
if self.files:
resources['files'] = self.files
if self.js:
resources['js'] = self.js
if self.css:
resources['css'] = self.css
if not resources:
return None
return resources
@resources.setter
def resources(self, value):
if not value:
self.files = None
self.js = None
self.css = None
elif not isinstance(value, dict):
raise errors.HighchartsValueError('resources expects a dictionary with keys "files", "js", and "css"')
else:
self.files = value.get('files', None)
self.js = value.get('js', None)
self.css = value.get('css', None)
@property
def files(self) -> Optional[List[str]]:
"""Collection of files that will be loaded into context for the export.
Defaults to :obj:`None <python:None>`.
:rtype: :class:`list <python:list>` of :class:`str <python:str>` or
:obj:`None <python:None>`
"""
return self._files
@files.setter
def files(self, value):
if not value:
self._files = None
else:
if isinstance(value, str):
value = [value]
elif not checkers.is_iterable(value):
raise errors.HighchartsValueError('files expects a list of strings')
self._files = value
@property
def js(self) -> Optional[str]:
"""JavaScript code that will be loaded into context for the exported chart.
Defaults to :obj:`None <python:None>`.
:rtype: :class:`str <python:str>` or :obj:`None <python:None>`
"""
return self._js
@js.setter
def js(self, value):
if not value:
self._js = None
else:
if not isinstance(value, str):
raise errors.HighchartsValueError('js expects a string')
self._js = value
@property
def css(self) -> Optional[str]:
"""CSS code that will be loaded into context for the exported chart.
Defaults to :obj:`None <python:None>`.
:rtype: :class:`str <python:str>` or :obj:`None <python:None>`
"""
return self._css
@css.setter
def css(self, value):
if not value:
self._css = None
else:
if not isinstance(value, str):
raise errors.HighchartsValueError('css expects a string')
self._css = value
[docs] @classmethod
def is_export_supported(cls, options) -> bool:
"""Evaluates whether the Highcharts Export Server supports exporting the series types in ``options``.
:rtype: :class:`bool <python:bool>`
"""
if not isinstance(options, HighchartsOptions):
return False
if not options.series:
return True
series_types = [x.type for x in options.series]
for item in series_types:
if item in constants.EXPORT_SERVER_UNSUPPORTED_SERIES_TYPES:
return False
return True
@classmethod
def _get_kwargs_from_dict(cls, as_dict):
url = as_dict.get('url', None)
protocol = None
domain = None
port = None
path = None
if not url:
protocol = as_dict.get('protocol', None)
domain = as_dict.get('domain', None)
port = as_dict.get('port', None)
path = as_dict.get('path', None)
kwargs = {
'options': as_dict.get('options', None),
'format_': as_dict.get('type', as_dict.get('format_', 'png')),
'scale': as_dict.get('scale', 1),
'width': as_dict.get('width', None),
'callback': as_dict.get('callback', None),
'constructor': as_dict.get('constructor',
None) or as_dict.get('constr', None),
'use_base64': as_dict.get('use_base64', None) or as_dict.get('b64', False),
'no_download': as_dict.get('noDownload',
None) or as_dict.get('no_download', None),
'async_rendering': as_dict.get('asyncRendering',
False) or as_dict.get('async_rendering',
False),
'global_options': as_dict.get('global_options',
None) or as_dict.get('globalOptions',
None),
'data_options': as_dict.get('data_options',
None) or as_dict.get('dataOptions', None),
'custom_code': as_dict.get('custom_code',
None) or as_dict.get('customCode', None)
}
if url:
kwargs['url'] = url
if protocol:
kwargs['protocol'] = protocol
if domain:
kwargs['domain'] = domain
if port:
kwargs['port'] = port
if path:
kwargs['path'] = path
return kwargs
def _to_untrimmed_dict(self, in_cls = None) -> dict:
untrimmed = {
'url': self.url,
'options': self.options,
'type': self.format_,
'scale': self.scale,
'width': self.width,
'callback': self.callback,
'constr': self.constructor,
'b64': self.use_base64,
'noDownload': self.no_download,
'asyncRendering': self.async_rendering,
'globalOptions': self.global_options,
'dataOptions': self.data_options,
'customCode': self.custom_code,
'resources': self.resources,
}
return untrimmed
[docs] def request_chart(self,
filename = None,
auth_user = None,
auth_password = None,
timeout = 3,
**kwargs):
"""Execute a request against the export server based on the configuration in the
instance.
:param filename: The name of the file where the exported chart should (optionally)
be persisted. Defaults to :obj:`None <python:None>`.
:type filename: Path-like or :obj:`None <python:None>`
:param auth_user: The username to use to authenticate against the
Export Server, using :term:`basic authentication`. Defaults to
:obj:`None <python:None>`.
:type auth_user: :class:`str <python:str>` or :obj:`None <python:None>`
:param auth_password: The password to use to authenticate against the Export
Server (using :term:`basic authentication`). Defaults to
:obj:`None <python:None>`.
:type auth_password: :class:`str <python:str>` or :obj:`None <python:None>`
:param timeout: The number of seconds to wait before issuing a timeout error.
The timeout check is passed if bytes have been received on the socket in less
than the ``timeout`` value. Defaults to ``3``.
:type timeout: numeric or :obj:`None <python:None>`
.. note::
All other keyword arguments are as per the :class:`ExportServer` constructor
:meth:`ExportServer.__init__() <highcharts_core.headless_export.ExportServer.__init__>`
:returns: The exported chart image, either as a :class:`bytes <python:bytes>`
binary object or as a base-64 encoded string (depending on the
:meth:`use_base64 <ExportServer.use_base64>` property).
:rtype: :class:`bytes <python:bytes>` or :class:`str <python:str>`
"""
self.options = kwargs.get('options', self.options)
self.format_ = kwargs.get('format_', kwargs.get('type', self.format_))
self.scale = kwargs.get('scale', self.scale)
self.width = kwargs.get('width', self.width)
self.callback = kwargs.get('callback', self.callback)
self.constructor = kwargs.get('constructor', self.constructor)
self.use_base64 = kwargs.get('use_base64', self.use_base64)
self.no_download = kwargs.get('no_download', self.no_download)
self.async_rendering = kwargs.get('async_rendering', self.async_rendering)
self.global_options = kwargs.get('global_options', self.global_options)
self.custom_code = kwargs.get('custom_code', self.custom_code)
missing_details = []
if not self.options:
missing_details.append('options')
if not self.format_:
missing_details.append('format_')
if not self.constructor:
missing_details.append('constructor')
if not self.url:
missing_details.append('url')
if missing_details:
raise errors.HighchartsMissingExportSettingsError(
f'Unable to export a chart.'
f'ExportServer was missing '
f' following settings: '
f'{missing_details}'
)
basic_auth = None
if auth_user and auth_password:
basic_auth = requests.HTTPBasicAuth(auth_user, auth_password)
payload = {
'infile': 'HIGHCHARTS FOR PYTHON: REPLACE WITH OPTIONS',
'type': self.format_,
'scale': self.scale,
'constr': self.constructor,
'b64': self.use_base64,
'noDownload': self.no_download,
}
if self.width:
payload['width'] = self.width
if self.height:
payload['height'] = self.height
if self.callback:
payload['callback'] = 'HIGHCHARTS FOR PYTHON: REPLACE WITH CALLBACK'
if self.global_options:
payload['globalOptions'] = 'HIGHCHARTS FOR PYTHON: REPLACE WITH GLOBAL'
if self.custom_code:
payload['customCode'] = 'HIGHCHARTS FOR PYTHON: REPLACE WITH CUSTOM'
if self.resources:
payload['resources'] = self.resources
as_json = json.dumps(payload)
if not self.is_export_supported(self.options):
raise errors.HighchartsUnsupportedExportError('The Highcharts Export Server currently only supports '
'exports from Highcharts (Javascript) v.10. You are '
'using a series type introduced in v.11. Sorry, but '
'that functionality is still forthcoming.')
options_as_json = self.options.to_json(for_export = True)
if isinstance(options_as_json, bytes):
options_as_str = str(options_as_json, encoding = 'utf-8')
else:
options_as_str = options_as_json
as_json = as_json.replace('"HIGHCHARTS FOR PYTHON: REPLACE WITH OPTIONS"',
options_as_str)
if self.callback:
callback_as_json = self.callback.to_json(for_export = True)
if isinstance(callback_as_json, bytes):
callback_as_str = str(callback_as_json, encoding = 'utf-8')
else:
callback_as_str = callback_as_json
as_json = as_json.replace('"HIGHCHARTS FOR PYTHON: REPLACE WITH CALLBACK"',
callback_as_str)
if self.global_options:
global_as_json = self.global_options.to_json(for_export = True)
if isinstance(global_as_json, bytes):
global_as_str = str(global_as_json, encoding = 'utf-8')
else:
global_as_str = global_as_json
as_json = as_json.replace('"HIGHCHARTS FOR PYTHON: REPLACE WITH GLOBAL"',
global_as_str)
if self.data_options:
data_as_json = self.data_options.to_json(for_export = True)
if isinstance(data_as_json, bytes):
data_as_str = str(data_as_json, encoding = 'utf-8')
else:
data_as_str = data_as_json
as_json = as_json.replace('"HIGHCHARTS FOR PYTHON: REPLACE WITH DATA"',
data_as_str)
if self.custom_code:
code_as_json = self.custom_code.to_json(for_export = True)
if isinstance(code_as_json, bytes):
code_as_str = str(code_as_json, encoding = 'utf-8')
else:
code_as_str = code_as_json
as_json = as_json.replace('"HIGHCHARTS FOR PYTHON: REPLACE WITH CUSTOM"',
code_as_str)
result = requests.post(self.url,
data = as_json.encode('utf-8'),
headers = { 'Content-Type': 'application/json' },
auth = basic_auth,
timeout = timeout)
result.raise_for_status()
if filename and self.format_ != 'svg':
with open(filename, 'wb') as file_:
file_.write(result.content)
elif filename and self.format_ == 'svg':
content = str(result.content, encoding="utf-8").replace("\u200b", " ")
with open(filename, 'wt') as file_:
file_.write(content)
return result.content
[docs] @classmethod
def get_chart(cls,
filename = None,
auth_user = None,
auth_password = None,
timeout = 3,
**kwargs):
"""Produce an exported chart image.
:param filename: The name of the file where the exported chart should (optionally)
be persisted. Defaults to :obj:`None <python:None>`.
:type filename: Path-like or :obj:`None <python:None>`
:param auth_user: The username to use to authenticate against the
Export Server, using :term:`basic authentication`. Defaults to
:obj:`None <python:None>`.
:type auth_user: :class:`str <python:str>` or :obj:`None <python:None>`
:param auth_password: The password to use to authenticate against the Export
Server (using :term:`basic authentication`). Defaults to
:obj:`None <python:None>`.
:type auth_password: :class:`str <python:str>` or :obj:`None <python:None>`
:param timeout: The number of seconds to wait before issuing a timeout error.
The timeout check is passed if bytes have been received on the socket in less
than the ``timeout`` value. Defaults to ``3``.
:type timeout: numeric or :obj:`None <python:None>`
.. note::
All other keyword arguments are as per the :class:`ExportServer` constructor
:meth:`ExportServer.__init__() <highcharts_core.headless_export.ExportServer.__init__>`
:returns: The exported chart image, either as a :class:`bytes <python:bytes>`
binary object or as a base-64 encoded string (depending on the ``use_base64``
keyword argument).
:rtype: :class:`bytes <python:bytes>` or :class:`str <python:str>`
"""
instance = cls(**kwargs)
exported_chart = instance.request_chart(filename = filename,
auth_user = auth_user,
auth_password = auth_password,
timeout = timeout)
return exported_chart